{ Capabilities }
Generating the server is the on-ramp. These are the 65 things MCPCloud does once it is running — auth, distribution, observability, cost control, and the exits.
Point MCPCloud at whatever you have. Every endpoint becomes a typed tool with a description an agent can actually act on.
Every tool description is rewritten for agent comprehension, because a spec summary written for humans reads as noise to a model.
Paste a spec or a URL and get a typed server, however large the surface.
Point at a GraphQL endpoint and its schema becomes discrete, well-scoped tools.
Give MCPCloud a repo with no OpenAPI file and it reads the handlers and synthesises the spec.
Generate a specification for an API that never had one, then review it before anything is built.
Describe the server you want in a sentence and get it built, tested and deployed.
Rename, re-describe, hide or hand-tune any generated tool before it ships.
The generated TypeScript is yours to read, export and run elsewhere.
Servers serve MCP prompts and resources, not just tools.
Strip fields from an upstream response before the model ever sees them, per tool.
Collapse a large tool surface behind search, get and use so an agent is not handed hundreds of definitions.
One home for a server’s whole life — not a build step that hands you a zip file and wishes you luck.
Every server runs on Cloudflare’s edge, so a tool call is not waiting on a container to wake up.
Streamable HTTP by default, SSE for older clients, and a stdio bridge for local work.
Run a server on isolated container infrastructure when the shared edge is not the right fit.
Serve from your own hostname with TLS handled for you.
Claim a clean, stable subdomain instead of a generated one.
Every deploy is a pinnable snapshot, and any of them can be restored in one click.
See which runtime a deployment is pinned to and update it deliberately.
Export the server with Docker and compose files and run it on your own infrastructure.
Require an organization approval before a deploy or another guarded action proceeds.
Deployments are probed after they land, and a stuck deploy is failed rather than left hanging.
Secrets never reach the generated source, and access is decided per tool and per caller rather than in a prompt.
Credentials are injected at call time and never written into the source you export.
Generated code is security-scanned before it is allowed to deploy.
Standard MCP clients authorize in the browser once and refresh their tokens automatically.
Each caller uses their own upstream credential, enrolled without pasting a key anywhere.
A shared server can resolve each member’s own OAuth connection at call time.
Grant or deny individual tools by role or member, enforced at the edge on every call.
Let people outside your organization connect, denied by default until you grant tools.
Mint keys limited to the exact resources and actions an integration needs.
Owner, admin, member and viewer roles gate every privileged action in the workspace.
Every privileged action is recorded with actor, target and time.
Each server carries its own request ceiling so one caller cannot exhaust an upstream.
Rotate the platform signing key with a bounded grace window instead of a hard cutover.
Know what your agents actually called, what it cost, and what broke — without wiring up a second product.
Inspect the request and response of any individual tool call after the fact.
See which tools are called, by which version, and how often.
Response projections report the tokens and dollars they saved, per day and per tool, with the pricing assumption named.
Track how long calls take and which ones fail, per tool and per deployment.
Call a tool against the live deployment and read the raw request and response pair.
Save a tool call as a scenario and re-run it whenever you change the server.
Read build and deploy output when something does not land the way you expected.
A public status page backed by real probes, not a manually updated badge.
Set a rolling spend ceiling with an optional hard stop enforced at the edge.
Every billable call is metered and visible, with credit packs when you need more headroom.
Publish once. Installers get versions, changelogs and a warning when you ship something new.
Every published server or skill gets a browsable, installable, indexable page.
Publish internally only, with the same versioning and none of the exposure.
Listings require a README and a changelog, so nobody installs something they cannot evaluate.
See everything your organization has installed and remove any of it.
Copy a published artifact into your own workspace and take it from there.
We tell you when a live server stops matching what its listing advertises.
Everyone who installed an artifact is told when you publish a new version.
Impersonation guards on publish, reporting on every listing, and a takedown path that actually stops the server.
The workflows that use your servers are versioned, testable packages — not prompts pasted between projects.
Author a skill as a package with its dependencies, guardrails and examples in one place.
Lay out a multi-step skill as a DAG instead of describing the order in prose.
Stop conditions and constraints travel with the skill rather than living in a prompt.
Export a skill as SKILL.md plus a dependency manifest and hand it to any agent.
Deploy a skill to its own runtime endpoint with the same versioning servers get.
Run a skill against saved cases and see what regressed before you publish.
Skills you install are served to a connected agent as MCP resources.
Everything above is reachable from a terminal, an API, or an agent — not only from this dashboard.
Deploy, roll back and inspect from a terminal, with JSON output for pipelines.
Over a hundred endpoints covering everything the dashboard can do.
MCPCloud is itself an MCP server, so Claude or Cursor can build and deploy for you.
Mirror server configuration to a Git repository as it changes.
Shared projects, per-seat billing, and roles that mean something.
Hide the depth until you want it, without moving anything to a different product.
Let your own users connect through your identity provider and keep your branding.
IP allowlisting · SAML single sign-on · Sandboxed JS interceptors · MCP server composition