Every part of an MCP server, from OpenAPI to MCP tools in one import.

Turn any API into an MCP server with the complete Model Context Protocol surface: tools, prompts, resources, four kinds of auth, real-time analytics, rate limits and an inspector. One install, anywhere PHP runs. You map endpoints; GetMCP speaks the protocol.

JSON-RPC 2.0 on MCP 2026-07-28 Streamable HTTP and SSE Four auth strategies No MCP code to write

Tools, prompts, resources and servers, all first class

GetMCP exposes the three core MCP primitives through a visual editor. Every primitive is inspectable, versioned and switchable per server.

Tools: your API as functions

Each tool maps to a single HTTP request. Define inputs with full JSON Schema; outputs are typed and validated; per-tool scopes and rate limits are enforced before the request leaves your server.

  • Visual parameter editor
  • Path, query, header and body mapping
  • Per-tool scopes and response transforms
  • Field-level redaction

Prompts: workflows in one tap

Pre-author parameterised templates that surface as slash commands inside Claude, Cursor and Windsurf. Bundle the right tools with the right framing, so users get the right answer on the first try.

  • Parameterised templates with defaults
  • Bundle the tools the prompt should call
  • Argument validation and previews
  • Surface as slash commands in clients

Resources: context the model can pull

Expose docs, records, files and live data as URI-addressable resources. The model fetches them on demand; you control what is discoverable, what is cached and what is gated.

  • URI-addressable docs and records
  • Static, dynamic or templated
  • MIME-typed responses
  • Optional caching with TTLs

Servers: one namespace per product or tenant

Run as many MCP servers as you need from a single install. Different products, different customers, different environments: each gets its own URL, auth and analytics.

  • Unique URL per server
  • Per-server auth strategy
  • Per-server logs and analytics
  • Clone and promote between environments

Bring the API definition you already have

Four import paths in, one clean tool spec out. Or hand-author a tool when you need something bespoke. Every imported tool is editable; nothing is locked in.

OpenAPI to MCP, from one menu

Open a server's tools tab, choose Import tools and pick the source. GetMCP reads the definition and generates tools with schemas, descriptions and parameter validation. Filter what to include before you commit.

  • Typed argument schemas generated for you
  • Security requirements carried into the tool config
  • Edit, trim or re-map any tool afterwards
The Import tools menu in GetMCP listing From cURL, OpenAPI spec, Swagger 2.0, Postman collection, Template and GetMCP export

cURL import

Paste any cURL request copied from your terminal, browser devtools or API docs. GetMCP parses the method, URL, query string, headers and body, and generates a tool with a typed argument schema in seconds.

OpenAPI 3.0 and 3.1

Upload an OpenAPI document, JSON or YAML, and GetMCP turns every operation into a tool, mapping schemas, descriptions, examples and security requirements. Filter what to include before you commit.

Swagger 2.0

Older Swagger 2.0 specs are first class. GetMCP normalises them into the same internal model as OpenAPI 3.x, so you do not have to migrate the spec to use it.

Postman v2.1

Import full Postman collections, including environments and variables. Auth, headers and pre-request scripts are translated into tool config; folders become tool groups.

Hand-authored tools

For endpoints you would rather not expose one to one, build a tool in the visual editor. Pick the verb, paste the URL template, define each argument and wire it to a downstream HTTP request. No code.

Templates

Start from a curated template: Stripe, GitHub, Notion, Slack, WooCommerce and more, pre-wired with sensible tool selections, so you can ship a useful server in minutes rather than hours.

Four auth strategies, passed through and never stored by us

GetMCP supports the four auth patterns real APIs use and forwards credentials end to end, so your existing permission model stays intact. Secrets are not proxied through our servers; nothing leaves your own server.

The credential your API already expects

Pick a strategy per server. GetMCP attaches the credential to every outbound request in the shape your API wants, whether that is a header, a query parameter or a token it refreshes for you.

  • Configured once per server, applied to every tool
  • Credentials stored encrypted on your server
  • Per-user tokens pass straight through from the MCP client
# API key, header or query parameter
X-Api-Key: sk_live_•••••

# Bearer token, static or per user
Authorization: Bearer eyJhbGciOi…

# Basic auth
Authorization: Basic YWRtaW46•••

# OAuth 2.0, refreshed automatically
grant_type=client_credentials  refresh: auto

API key

The simplest case: a single key, attached to every outbound request. Configure the header name (for example X-Api-Key) or the query parameter, and GetMCP injects it on every tool call.

Bearer token

Drop in a static bearer for service-to-service tools, or pass tokens through from the MCP client header so each user calls your API as themselves.

Basic auth

For legacy systems and intranet APIs that still rely on HTTP Basic. Credentials are stored encrypted on your server and never round-trip through the AI client.

OAuth 2.0 with automatic refresh

Full client-credentials and authorization-code flows, with automatic refresh. Configure the auth URL, token URL, scopes and client credentials; GetMCP keeps tokens fresh.

See exactly what AI is doing with your API

Every tool call is logged with timing, payload size, response status and the client that made it. Filter, replay and export without leaving the dashboard.

Every call, on one dashboard

Calls, latency, errors and clients for every server you run, on the same screen you manage them from. Drill into any call to see the request body, the upstream response and the timing for every hop.

The GetMCP dashboard overview showing call volume, latency and status for the MCP servers on one install

Live call stream

Watch tool calls land as they happen. Drill into any call to see the request body, the upstream response and the timing for every hop.

Client attribution

See which calls came from Claude Desktop, ChatGPT, Cursor, Windsurf or anything else. Spot abuse, prioritise support and decide what to optimise.

Per-tool health

P50 and P95 latency, error rates and call counts at the tool level. Catch a regressing endpoint before users do.

Take your data with you

Filter logs by date, server, tool, client or status, then export the result as JSON or CSV. Your data stays portable, with no lock-in.

Production-grade controls, built in

Rate limits, retries, an inspector and templates: the operational tooling you would otherwise build yourself.

Per-client limits, applied to every server

Set a per-client rate limit once, and GetMCP applies it independently to every server you run. A client hitting 60 requests a minute on Server A still has its own 60 requests a minute on Server B. GetMCP retries 5xx responses with exponential backoff before failing the call, so a flaky upstream does not break the agent flow.

  • One global per-client policy, applied per server
  • Sliding-window or fixed-bucket counters
  • Exponential backoff with jitter on upstream 5xx
  • 429 responses surfaced cleanly to the client
# Rate policy, applied per server
per-client          60 / min

# applied independently to
production          60 / min / client
staging             60 / min / client

# upstream 5xx
retry               3 attempts, 1s 2s 4s

Test every tool before users see it

The Inspector is a built-in playground that calls your MCP server exactly the way Claude or Cursor will. Run any tool with real inputs, see the raw response and replay calls from production logs with one click.

  • Run any tool with custom arguments
  • See request, response and timing
  • Replay any call from production logs
  • No external client required
POST /mcp/my-mcp-server/tools/call
{
  "tool": "create_invoice",
  "arguments": {
    "customer_id": "cus_8f21",
    "amount": 2400,
    "currency": "usd"
  }
}

200 OK  142 ms  replay this call

Curated starting points, ready to ship

Start from a template instead of a blank server. Each template ships with a curated set of tools, the ones that are actually useful, so you skip the "which 80 endpoints do I expose?" question entirely.

  • Stripe, GitHub, Notion, Slack, Linear
  • WooCommerce, WordPress, MailChimp
  • Custom internal templates per workspace
  • Fork and customise without losing updates
The GetMCP templates gallery with Mailbox IMAP, Database, Open-Meteo, GitHub, Stripe and Slack templates

Spec-correct, every release

GetMCP is a full implementation of the Model Context Protocol, not a subset. When the spec moves, an update brings it forward. Your tools keep working.

Full JSON-RPC 2.0

Every method the MCP spec defines, initialize, tools/list, tools/call, prompts/get and resources/read, is implemented and conformance-tested.

Streamable HTTP and SSE

Negotiated automatically per client. Long-running tool calls stream incremental progress; one-shot calls use plain HTTP.

Versioned tool specs

Deprecate tools, add fields or change schemas without breaking existing clients. GetMCP supports protocol negotiation and side-by-side tool versions.

One-click protocol updates

When MCP ships a new revision, we ship an update. Your existing tool definitions keep working. You do not migrate; the update does.

Every feature you would build. None of the plumbing.

Install GetMCP, import your API, share one URL. Your users will start calling your tools from Claude tonight.

Teams already shipping MCP servers with it

Rated 5.0 out of 5 by customers Read more reviews

I really like GetMCP. It makes my work much easier, and the connection stays stable without constant reconnecting. Through one MCP connection, I can give my AI access to the services I choose and let it handle many useful tasks across my tools.

Hamza El

Picked up GetMCP to connect our internal tools, and the initial setup was surprisingly fast. Probably saved me hours of configuration work. Looking forward to expanding our usage and future features.