Spec, GraphQL, or just your repo

Turn any API intoa live MCP server.

Paste a spec — or point MCPCloud at a repo that hasn’t got one. Every endpoint becomes a typed tool with a description Claude rewrote for agents, deployed to a global edge runtime with auth, secrets, and observability already wired.

5 min

Spec to first live deployment.

3 sources

OpenAPI, GraphQL, or a repo with no spec at all.

0 config

No scaffolding, no config files to maintain.

Running todayStripeGitHub— real servers, real calls.

tally-mcp

Live

21 tools · global edge

$ claude mcp add tally \

--transport http \

https://tally.mcp.mcpcloud-demo.com/mcp

✓ Connected — 21 tools available

confirm_payment_intent

Enriched
−
“Confirm Payment Intent”
+
“Confirm a payment intent to process the associated payment. This operation finalizes a payment intent that was previously created, optionally binding it to a specific payment method. Once confirmed, the payment will be charged against the customer’s account. This is a critical operation in the payment workflow and should only be called when you are ready to commit the transaction.”

+ 20 more rewritten for agents

How it works

A pipeline tuned for agents, not codegen theater.

Paste a spec. MCPCloud extracts every endpoint as a typed tool, generates a ready-to-deploy MCP server, and pushes it to a global edge runtime — no scaffolding, no config files.

Tool description · confirm_payment_intent
From the spec

Confirm Payment Intent

Agent-readable

Import
Pending
OpenAPIGraphQLGitHub
api.tally.mcpcloud-demo.com/openapi.json
0 / 21 endpoints
Generate
Pending
Deterministic codegen
tools/confirm-payment-intent.ts
Waiting…
Deploy
Pending
Global edge runtime
public
tally-mcp/
—

Tally is a real MCP server, built on MCPCloud end to end. That run wasn't a mockup — here's the live deployment.

Next · Push v1.1 → drift detection diffs the added /disputes group.

Tool descriptions stay editable
Secrets never land in generated source
Deployable output remains portable
Skill packages stay editable before publish

Your API doesn't need a spec to live here.

Point Spec Studio at your repository. It inventories your routes, infers a reviewed OpenAPI spec per endpoint — confidence-annotated, verified against your live API — and hands you a spec you keep. Then it becomes an MCP server on the platform: policy proxy, keys, observability, distribution.

Scan your repoRead the docs

Convex · FastAPI · Express · NestJS · anything (LLM fallback) — scanning is free, generation ≈ 1 credit per route, and the spec is yours either way.

$ mcpcloud spec scan acme/api@main

inventoried 121 routes · adapter: convex · free

$ mcpcloud spec generate --all

✓ 118 generated · 3 to review · 2m 41s

✓ verified against the live API · 34 endpoints matched

$ mcpcloud server create --from-spec

● acme-api.mcp.acme.dev — live, policy-fronted, observable

Real, installable MCP servers — today

We pointed MCPCloud at the published Stripe and GitHub OpenAPI specs, curated a useful subset, and shipped both. Toggle between them below — every call hits the real upstream through the deployed MCP server.

Stripe MCP (test mode)·~470 ops parsed → 34 curated tools·api.stripe.com
Calls run through the MCPCloud edge, rate-limited to 60 req/min and scoped to a shared sandbox tenant that resets daily.Full Stripe showcase
Code ModeLive

Your agent writes the loop. Not your context window.

Forty tool calls used to mean forty round trips through the model, every intermediate payload burning tokens on its way to the next call. Now the agent writes the loop once and runs it next to your tools. Only the answer comes back.

1,940

tokens into context, from 118,400

1

model turn, from 41

41

calls made, each still fully authorized

Read the docsSee real runs

Worked example: “Which open PRs have failing CI, and who wrote them?” over 40 pull requests. Same calls, same authorization path, 61× less of it in context.

What the agent submits

(async () => {
  const prs = await tool("pullsList", { state: "open" })
  const failing = []

  for (const pr of prs) {
    const checks = await tool("checksListForRef", { ref: pr.head.sha })
    if (checks.check_runs.some((c) => c.conclusion === "failure")) {
      failing.push({ pr: pr.number, author: pr.user.login })
    }
  }
  return failing
})()

Runs in a WebAssembly sandbox with no network and no filesystem — only your tools. Destructive tools are refused inside it.

Author agent behaviors, not just APIs.

A skill is a reusable, versioned agent behavior package. Skill Studio is a visual composition canvas: pick MCP server dependencies, drop step nodes onto the graph, and wire success and fallback edges. The canvas compiles into a structured package with triggers, guardrails, and an editable SKILL.md.

Workflow topology

Success edges follow step order. Dashed edges show fallback.

4 steps

Entry

Start here

linear · on_issue_closed

validate_lead

validator

Stop on errorout: leadReady

enrich_company

enrichment-mcp

Continue on errorout: firmographicsReady

update_deal

crm-mcp

Fallback on errorout: assignment1 issue

Generated skill package

Meeting Notes → Action Items

Livev1.0.0

Trigger phrases

extract action itemsmeeting notes to taskssync meeting actions

Dependencies

slate-mcp · list_page_blocks
slate-mcp · query_database
slate-mcp · create_database_page

Guardrails

3 stop conditions ship inside the package — written into SKILL.md and versioned with it, not left as comments in a prompt.

Read the skill format

Everything a production MCP server actually needs

Generation gets a server to live. The platform keeps it there — deployment, auth, rate limits, secret injection, versioning, and observability, opinionated where reliability matters.

Global edge runtime

Generated servers run on a global edge runtime with sub-5ms cold starts and automatic distribution across 300+ locations worldwide.

fra 41msiad 12mssin 38ms

Auth built-in

API Key, OAuth 2.0, and custom headers — all supported. Secrets are encrypted and injected at runtime, never in source.

Per-tool usage analytics

Track install counts, active usage, error rates, and latency per tool per version — directly in the dashboard.

Multi-transport support

Streamable HTTP by default, SSE for legacy clients, stdio for local development.

Immutable versions and rollback

Major bumps flag breaking changes, clients pin exact versions, and any deploy rolls back in one click.

CLI for CI/CD

Deploy from GitHub Actions and script everything — every command supports --json.

See all 69 capabilities

The shared registry for MCP skills and servers.

Publish once, install anywhere. The registry handles versioning, discovery, and dependency-aware activation — so you can focus on building.

Live registry

Marketplace

Real public listings on MCPCloud right now — every card opens the actual marketplace page.

Servers—
Skills—
Browse the full marketplace

Served automatically: the first time an agent calls a protected tool, the run pauses, your user connects here, and the tool call retries with their key.

Your users connect on your brand, not ours.

A deployed server isn’t something we hand back for you to integrate — it ships with its own front door. Your end users get a hosted connect page carrying your logo, accent, and key docs. They paste their key once; it’s stored encrypted, injected only at request time, and their agent only ever holds a short-lived token.

Or skip the paste entirely: with federation, your existing sign-in is the integration. Your backend signs a short-lived assertion, sends the user over, and they land already connected — no MCPCloud signup, nothing to type.

See the end-user access plane

Denied by default until you grant tools · per-user keys, revocable anytime · OAuth 2.1 consent with provenance warnings for unknown clients.

Stripe changed 9 of your tools last night.

Upstream APIs do not hold still. A generator hands you code and the relationship ends there — nothing is watching when the spec moves, so your server quietly stops matching it and you find out from a customer whose agent called a tool that no longer exists.

MCPCloud re-reads the spec every day and tells you exactly what moved: which of your live tools changed or were removed, and which new operations you do not have yet. New ones become draft tools in a click — enrich and redeploy, and you are back in sync.

See what else the platform watches

Checked daily · the alert names the server, not just the project · nothing changes until you say so.

A real diff from Stripe’s OpenAPI spec, rendered by the same component the product uses.

Live

Your server is a repo. The PR was red before you merged it.

A generator hands you code once and the relationship ends. MCPCloud mirrors the generated server into a repository you own — source, config manifest, even the authoring rules your coding agent needs — and keeps the relationship going in both directions.

Push, and the change comes back through the same safety gate the dashboard enforces, becomes a version, and the sandbox suite runs against exactly the code you pushed — verdict on the commit, red or green, before anything merges. Clone it anywhere and mcp dev serves straight from your checkout.

See the git loop in the CLI docs

Conflicts are refused, never overwritten · unsafe handlers fail the check before merge · the mirror is additive, your README stays yours.

A real pull request from this feature’s own verification run — verdicts verbatim.

The whole platform, operable from your agent.

MCPCloud ships as an MCP server on its own marketplace — the official MCPCloud listing plus five official skills. Connect Claude, Cursor, or any MCP client with one approval: a scoped key is minted and custodied server-side, every destructive action stays guarded, and everything runs in your workspace under your role.

See it on the marketplaceRead the docs

Zero-paste connect · revocable any time · the official server is write-locked, so an agent can never modify the thing it speaks through.

$ mcp connect-agent

✓ connected — key custodied, agent never sees it

claude mcp add mcpcloud --transport http https://…/mcp

$ “ship an MCP server for our payments API”

● spec ingested · descriptions enriched · tests 12/12

deploy is guarded — your agent asks before going live

Pricing

Simple, transparent pricing

Start free, move into hosted billing, and scale into governed collaborative access.

Save 17%

A credit is $0.10 — about one generated tool. Running them costs far less: 0.15 credits per 1,000 tool calls. A 20-endpoint API is roughly 20 credits to build, then pennies to keep serving.

Free

$0forever

Individual builders

Test the full platform end-to-end with 30 included credits — no card required.

Includes

  • 30 welcome credits
  • 2 MCP servers
  • Public registry access

No credit card required

Choose Free

Pro

Most popular
$39per seat / month

Small teams

Private registry, shared projects, and seat-based pricing for shipping real agents.

Includes

  • 500 monthly credits
  • Private registry
  • Shared projects

Ship faster with shared workspaces

Choose Pro

Enterprise

Customannual contract

Regulated orgs

Dedicated infrastructure, self-hosted export, and governance for compliance and scale.

Includes

  • Custom credit volume
  • Dedicated containers on larger instances

On the roadmap — SAML SSO.

Custom rollout — tell us what you need

Talk to us
Help me choose a plan

Marketplace creators keep 75% of revenue once paid listings launch. Contact us for enterprise rollout support.

Ready to ship?

Launch your next MCP server. Author the skills that run on it.

Start free, keep the generated source, and go from imported spec to a live deployment in one pass.

Typed outputSkill authoringEdge runtime deploysSource included