How I Turned 100,000+ APIs into MCP Servers with a Cloudflare Worker

FlashMCP — Sat, 07 Mar 2026 19:31:24 +0000

I built FlashMCP, a gateway that turns any REST API into an MCP server on the fly. Here's how the architecture works.

The request flow

When a POST hits flashmcp.dev/api.stripe.com:

URL parsing — Extract target host (api.stripe.com), base path, and optional ?spec= parameter
Short-circuit — initialize and ping don't need a spec. Return immediately.
Spec resolution — Check Cloudflare Cache API → fetch explicit ?spec= URL → auto-discover
Tool mapping — Parse OpenAPI spec, map all endpoints to MCP tool definitions
JSON-RPC dispatch — Route tools/list or tools/call to the right handler
Upstream proxy — Build request, forward auth headers, call the real API
Response formatting — JSON → text, images → base64 content blocks, 204 → confirmation message

All in a single Cloudflare Worker. No containers, no state, no cold starts.

Auto-discovery: finding the spec

Most APIs don't tell you where their OpenAPI spec is. FlashMCP uses a 3-phase discovery system:

Phase 1: apis.guru — A community directory of 2,500+ API specs. We check if the target host has an entry.

Phase 2: HTTP Link header — Per RFC 8631, APIs can advertise their spec via:

Link: </openapi.json>; rel="service-desc"

Phase 3: .well-known/api-catalog — Per RFC 9727, fetch https://target/.well-known/api-catalog for a JSON catalog of API descriptions.

Total: max 3-4 HTTP requests. Results cached for 5 minutes.

The $ref problem

OpenAPI specs use JSON $ref pointers for schema reuse. A pet store spec might have:

{
  "Pet": {
    "properties": {
      "category": { "$ref": "#/components/schemas/Category" },
      "tags": {
        "items": { "$ref": "#/components/schemas/Tag" }
      }
    }
  }
}

Simple, right? Until you hit circular references:

{
  "TreeNode": {
    "properties": {
      "children": {
        "items": { "$ref": "#/components/schemas/TreeNode" }
      }
    }
  }
}

FlashMCP's resolveSchemaRefs() tracks visited references and replaces circular refs with { type: "object", description: "(circular reference)" }. No external dependencies — just recursive descent with a Set.

Body flattening

LLMs are bad at nesting. When an API expects:

POST /pets
{ "name": "Rex", "status": "available" }

A naive MCP server would define the tool as:

createPet({ body: { name: "Rex", status: "available" } })

LLMs frequently forget the body wrapper. FlashMCP flattens body fields into the top-level schema:

createPet({ name: "Rex", status: "available" })

Then reconstructs the body from non-parameter arguments at call time.

Pagination for large APIs

Some APIs have 500+ endpoints. Dumping all tools in one response overwhelms LLMs. FlashMCP uses cursor-based pagination — 50 tools per page, with a nextCursor for more.

What I learned

KV TTL minimum is 60 seconds — Cloudflare KV throws a 400 if you set expirationTtl below 60. This surfaces as a generic 1101 error to clients.
new URL(path, base) strips base paths — new URL("/pets", "https://api.com/v3") gives https://api.com/pets, not https://api.com/v3/pets. Use string concatenation.
Stateless is enough — MCP supports sessions, but for a proxy gateway, stateless works perfectly. Each request is independent.

Try it: flashmcp.dev | Playground | Gallery

Stop Building MCP Servers. Use a URL Instead.

FlashMCP — Sat, 07 Mar 2026 19:27:46 +0000

Every time you want your LLM to interact with an external API via MCP, you write something like this:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

const server = new McpServer({ name: "my-api", version: "1.0" });

server.tool("listUsers", "List all users", { page: z.number() }, async ({ page }) => {
  const res = await fetch(`https://api.example.com/users?page=${page}`);
  const data = await res.json();
  return { content: [{ type: "text", text: JSON.stringify(data) }] };
});

// ... repeat for every endpoint
// ... handle auth forwarding
// ... deploy somewhere
// ... maintain forever

For ONE API. Now multiply that by every API you want to connect.

There's a better way

FlashMCP is a hosted gateway that does all of this automatically. Your entire config:

{
  "mcpServers": {
    "my-api": {
      "url": "https://flashmcp.dev/api.example.com"
    }
  }
}

Done. FlashMCP:

Auto-discovers the OpenAPI spec (via apis.guru, HTTP Link headers, or .well-known/api-catalog)
Parses every endpoint into MCP tool definitions
Resolves complex $ref chains (including circular references)
Proxies your calls to the upstream API
Returns properly typed MCP content blocks (text, images, audio)

Try it in 60 seconds

Option A: Playground (no signup)

Go to flashmcp.dev/playground and try any API interactively.

Option B: Claude Desktop

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "petstore": {
      "url": "https://flashmcp.dev/petstore3.swagger.io/api/v3?spec=/api/v3/openapi.json"
    }
  }
}

Restart Claude Desktop. Ask: "What tools do you have for the pet store?"

It just works.

Option C: Cursor

Same config in your Cursor MCP settings. Every endpoint becomes a tool your AI can call.

Connecting authenticated APIs

FlashMCP forwards standard auth headers to the upstream API:

{
  "mcpServers": {
    "github": {
      "url": "https://flashmcp.dev/api.github.com",
      "headers": {
        "Authorization": "Bearer ghp_your_token"
      }
    }
  }
}

Your LLM can now create repos, open issues, merge PRs — whatever the GitHub API supports.

100,000+ APIs ready to go

Browse the full gallery at flashmcp.dev/gallery. Stripe, Twilio, Shopify, Notion, Discord, Slack — if it has an OpenAPI spec, it's there.

Pricing

Free: 1,000 requests/month
Paid: $1 per 1,000 requests (prepaid credits, no subscription)

Only actual tool calls (API requests) count. Protocol messages like initialize and tools/list are always free.

FlashMCP | Playground | Gallery | Docs

DEV Community: FlashMCP