canonical: https://jentic.com/apis/meshery.io/meshery

# Meshery API

Jentic publishes the only available OpenAPI specification for Meshery API, keeping it validated and agent-ready. Meshery is the open-source cloud-native management plane for service meshes and Kubernetes, used to design, deploy, and operate workloads across multiple clusters and meshes. The 170-endpoint API spans application files, environments, connections, designs, filters, performance profiles, smart provisioning, and content sharing, exposing the operations needed to drive Meshery from CI pipelines, custom dashboards, or automation agents.

## For AI agents

Manage Meshery applications, designs, environments, connections, and performance profiles through 170 endpoints.

## Scope

Does not handle raw container builds, low-level Kubernetes object CRUD, or cloud-provider IAM - use for Meshery-managed application, environment, design, and performance operations only.

## Capabilities

- Upload, deploy, and remove Meshery application files for declarative workload rollouts
- Manage environments and the connections registered to each environment for multi-cluster setups
- Share designs, filters, and other content between teams using the dedicated share endpoints
- Run and inspect performance profiles to benchmark service-mesh and workload behaviour
- Drive smart provisioning of meshes and supporting components from a single API surface
- Trigger application deploys and undeploys from CI pipelines using the deploy endpoints

## Use cases

### GitOps-Style Application Rollouts

Platform teams using Meshery to manage cloud-native workloads can wire CI pipelines into the application endpoints to upload manifests with POST `/api/application/{sourcetype}` and roll them out via POST `/api/application/deploy.` DELETE `/api/application/{id}` and DELETE `/api/application/deploy` handle teardown for ephemeral environments, supporting GitOps-style rollouts across clusters.

Example prompt: Call POST `/api/application/{sourcetype}` to upload the manifest, then POST `/api/application/deploy` to roll it out to the target environment.

### Multi-Environment Connection Management

Operators running Meshery across multiple clusters and meshes can model each as a Meshery environment and attach the relevant connections (Kubernetes contexts, mesh adapters) using POST `/api/environments` and POST `/api/environments/{environmentID}/connections/{connectionID}.` The corresponding GET and DELETE operations support inventory and cleanup as the topology evolves.

Example prompt: Call POST `/api/environments` to create a staging environment and POST `/api/environments/{environmentID}/connections/{connectionID}` to attach the staging Kubernetes connection.

### Design Sharing Across Teams

Internal platforms can let teams reuse Meshery designs and filters by routing them through POST `/api/content/design/share` and POST `/api/content/filter/share.` This keeps reference architectures discoverable inside the organisation without forcing teams to copy YAML between repositories.

Example prompt: Call POST `/api/content/design/share` with the design ID to publish a reference design to the platform team's catalogue.

### Performance Profiling Workflow

Reliability teams can run Meshery performance profiles to characterise workload and mesh behaviour, surface regressions before deploys, and hand the resulting profiles back to designers as inputs for sizing decisions. The performance endpoints in the API drive both the run and the retrieval of the resulting reports.

Example prompt: Trigger a performance profile run against the staging environment and retrieve the resulting report for the on-call review.

### Agent-Driven Mesh Operations

An AI agent embedded in a platform team's workflow can take instructions like 'deploy the new app to staging', 'list the connections in the prod environment', or 'share this design with the SRE team'. Through Jentic the agent finds the matching Meshery operation, loads the schema, and executes it without writing custom Meshery client code.

Example prompt: Search Jentic for 'deploy a Meshery application', load POST `/api/application/deploy`, and execute it with the application ID and environment from the user's instruction.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/application/{sourcetype}` | Upload a Meshery application file |
| POST | `/api/application/deploy` | Deploy a Meshery application |
| DELETE | `/api/application/deploy` | Undeploy a Meshery application |
| DELETE | `/api/application/{id}` | Delete a Meshery application file |
| GET | `/api/environments` | List Meshery environments |
| POST | `/api/environments` | Create a new environment |
| POST | `/api/environments/{environmentID}/connections/{connectionID}` | Attach a connection to an environment |
| POST | `/api/content/design/share` | Share a Meshery design |

## Key resources

- **Application** — Upload, deploy, and manage Meshery application files
- **Environments** — Model environments and their attached connections
- **Designs** — Reusable Meshery designs and sharing
- **Filters** — Mesh filters and configuration content
- **Performance** — Performance profiling and benchmarking
- **Smart Provisioning** — Provision meshes and supporting components

## Why Jentic

- **Setup:** Wiring the Meshery API by hand means carrying its session token cookie on every request against meshery.io, shaping the application, environment, and design request bodies, and handling retries yourself. Through Jentic you install once, import the Meshery API from the API Directory, store the session credential once, and your agent calls it.
- **Permission scoping:** Meshery puts the application and environment ids in the URL path (`/api/application/{id}` and `/api/environments/{environmentID}/connections/{connectionID}`), so a rule can pin your agent to one application or environment. You choose the operations it may call, so destructive ones like application deletion or deploy teardown are not included unless you add them.
- **Credential handling:** Your Meshery session credential is stored once, encrypted, by your own Jentic One instance and attached as the token cookie at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'deploy a Meshery application' or 'list Meshery environments', and Jentic returns the matching application, environment, or design operation with its request schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Kubernetes API** — Underlying API that Meshery orchestrates against
- **Rancher API** — Cluster management platform with multi-cluster operations
- **Docker Engine API** — Build and manage container images that Meshery deploys

## FAQ

### Why is there no official OpenAPI spec for Meshery API?

Meshery does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Meshery API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Meshery API use?

Meshery authenticates via a session cookie named token, set after the user signs in to the Meshery server. Through Jentic, that session credential is stored in the credential vault and the agent calls the API with a scoped Jentic token rather than handling the cookie directly.

### Can I deploy and undeploy applications with the Meshery API?

Yes. POST `/api/application/deploy` rolls out an application to its target environment and DELETE `/api/application/deploy` tears it down. The application file itself can be removed with DELETE `/api/application/{id}` when it is no longer needed.

### What are the rate limits for the Meshery API?

The OpenAPI spec does not declare explicit rate limits. Meshery is typically self-hosted, so limits depend on the deployment; high-volume CI use should sequence calls per environment and back off on 5xx responses to avoid overloading the Meshery server.

### How do I share a Meshery design through Jentic?

Install the SDK with pip install jentic, search for 'share a Meshery design', load the POST `/api/content/design/share` operation, and execute it with the design ID. Jentic attaches the session credential and posts to the Meshery server.

### Does the Meshery API support multi-environment connections?

Yes. Environments are first-class resources via `/api/environments`, and connections are attached using POST `/api/environments/{environmentID}/connections/{connectionID}.` This is how Meshery models multiple clusters or meshes under a single management plane.

### Can I limit what my agent is allowed to do with the Meshery API?

Yes. Because you run Jentic One yourself, your own rules decide which Meshery operations and which stored session credential the agent may use. Meshery carries the application and environment identifiers in the URL path, such as `/api/application/{id}` and `/api/environments/{environmentID}/connections/{connectionID}`, so you can pin the agent to a single application or environment. You also choose the specific operations it can call, so destructive ones like application deletion or deploy teardown stay out of reach unless you add them.