Every SaaS is shipping an “MCP server” now. So is the API dead?
No. In the MCP vs API question, you usually need both.
An API lets your code call a service. MCP lets an AI model find that service’s actions and call them itself, through the same API underneath.
If your code makes the call, use the API. If a model picks the call, put MCP in front.
We built both over one dataset and measured them. MCP’s real cost wasn’t where we expected.
MCP vs API: what’s the actual difference?
An API is a contract between two programs. MCP is a contract between an AI app and the tools it may use.
A REST API says: send GET /posts/post-03 and get this JSON back. A developer reads the docs, writes the call and decides when it runs. Our guide to REST vs GraphQL vs SOAP covers the shapes that contract can take.
MCP, the Model Context Protocol, changes who’s in charge. The AI app asks a server what it can do.
It gets back a list of tools, each with a plain-English description and an input schema. The model then picks which one to call, mid-chat.
| API | MCP | |
|---|---|---|
| Who calls it | Your code, on a path you wrote | An AI model, on a path it picks |
| How it’s discovered | A developer reads the docs | The app asks the server for its tool list |
| Message format | Whatever the API uses (REST, GraphQL, gRPC) | JSON-RPC 2.0 for every server |
| Where it runs | A web server | A local process (stdio) or a URL (Streamable HTTP) |
| Built for | Any software | AI apps like Claude, ChatGPT, Cursor and VS Code |
So MCP isn’t a better API for your app. It’s a standard plug for AI apps, so one connector works in all of them. Our MCP explainer covers hosts, clients and servers if those terms are new.
How does MCP sit on top of an API?
Most MCP servers are thin wrappers around an API that already exists. The server translates; the API still does the work.

Here’s a complete MCP tool wrapping our test REST API. It’s 12 lines, and half of them are setup:
import httpx
from mcp.server.mcpserver import MCPServer
mcp = MCPServer("blog-wrapper")
api = httpx.Client(base_url="http://127.0.0.1:8001")
@mcp.tool()
def get_post(slug: str) -> dict:
"""Get one post by its slug."""
r = api.get(f"/posts/{slug}")
r.raise_for_status()
return r.json()
if __name__ == "__main__":
mcp.run()
What got added? No data, no logic: just a name, a typed argument and a one-line description. The model reads that docstring to decide whether to call get_post, so it’s the most important line in the file.
On top of the API, MCP standardises three things:
- Discovery. A
tools/listrequest returns every tool with its description and JSON schema. No docs page, no SDK to install. - One calling format. Every tool on every server is called with
tools/call. A Stripe tool and a GitHub tool look the same to the app. - Two transports. stdio runs the server as a local process the app launches. Streamable HTTP puts it at a URL, one POST per message. Our guide to connecting an MCP server shows where each kind goes in Claude, Cursor and ChatGPT.
We use this daily. Every post on this site, this one included, goes live through an AI agent calling a WordPress MCP server. Our Novamira review covers that setup: MCP tools on top of WordPress’s own functions.
We built the same API twice: what changed?
MCP lost on every wire measure. It barely mattered.
The setup: 24 made-up blog posts and three operations (list posts, get one post, count posts per category). We built a REST API with FastAPI and an MCP server with the official Python SDK 2.3.0, which speaks the July 2026 spec.
We called each 300 times per run, three runs, on one machine. Tokens were counted with OpenAI’s o200k tokenizer.
| Measure | REST API | MCP server |
|---|---|---|
| Lines of code (3 operations) | 22 | 28 (4 pick the transport) |
| Get one post: bytes on the wire | 400 | 1,016 (2.5x) |
| List 5 posts: response body | 601 bytes | 1,791 bytes (3x) |
| Get one post: tokens the model reads | 36 | 55 (+53%) |
| Median call time, local HTTP | 0.56 ms | 1.0 ms raw, 1.6 ms via the SDK |
What each one actually sends
Same post, two shapes. REST is one line in and compact JSON out:
GET /posts/post-03
{"slug":"post-03","title":"Sample post 03","category":"Proxy","words":1125,...}
MCP wraps the call in a JSON-RPC envelope with protocol metadata, and returns the post as pretty-printed text:
POST /mcp
Mcp-Method: tools/call
Mcp-Name: get_post
{"jsonrpc":"2.0","id":2,"method":"tools/call",
"params":{"name":"get_post","arguments":{"slug":"post-03"},
"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28", ...}}}
{"result":{"content":[{"type":"text","text":"{\n \"slug\": \"post-03\", ..."}],
"isError":false,"resultType":"complete"}}
The SDK pretty-prints results, so the model reads 53% more tokens for the same post. Typed list results go out twice, as text and as structuredContent, which explains the 3x body.
Is MCP slower than an API?
By about half a millisecond per call. You won’t feel it.
REST answered in a median 0.56 ms, raw MCP over HTTP in about 1.0 ms and our wrapper in 2.4 ms. A model spends whole seconds choosing a tool, so protocol overhead is a rounding error.
Startup is the delay you might notice. Our stdio server, a fresh process each time, took 0.5 to 0.6 seconds to launch and list its tools. Over HTTP, connecting took 20 ms.
Our take: Don’t choose between MCP and an API on speed or bytes. Both gaps are real and both are tiny. Choose on who makes the call.
The hidden cost: tool lists the model rereads every turn
Here’s what most MCP vs API comparisons miss. Every tool you connect sits in the model’s context before you type a word.
Most MCP apps put the full tool list into the prompt on every message. Our three tools cost 196 tokens. So we measured three popular open-source servers:
| MCP server | Tools | Tokens in the tool list |
|---|---|---|
| Filesystem (2.3.0) | 16 | 4,266 |
| Memory (2.1.1) | 9 | 3,288 |
| Playwright browser (0.0.85) | 25 | 4,585 |
| All three together | 50 | 12,139 |
That’s 12,139 tokens on every request, nearly a tenth of a 128K context window, gone before the model reads your question. A plain API costs zero here, because your code already knows what to call.
Anthropic hit the same wall at scale. In a November 2025 engineering post, it cut one agent workflow from 150,000 tokens to 2,000.
The fix: the agent wrote code against its MCP tools and loaded only the definitions it needed. The July 2026 spec helps too, with tools listed in a fixed order so prompt caches keep hitting.
Pasting raw API docs isn’t cheaper. FastAPI’s auto-generated OpenAPI file for our API ran 466 tokens, over double the MCP tool list.
Real-world tip: Connect only the servers a task needs and switch off tools you never use. Every tool you drop saves tokens on every message. Our agentic AI vs generative AI test shows how fast those bills grow once a model calls tools in a loop.
Is MCP safer than calling an API directly?
No. MCP adds a decision-maker, the model, so it adds risk. The protections live in the app and your setup, not the protocol.
With a normal API, your code holds the key and calls only what you wrote. Our API authentication guide covers keys, OAuth and tokens. The worst case is a bug you can find.
With MCP, the model chooses the calls, and the spec is blunt about the risk. Tools are arbitrary code execution, descriptions from an untrusted server are untrusted, and MCP “cannot enforce” its own security principles. It leaves consent to the app, which must ask you before any tool runs.
Authorisation is optional, too. Remote servers that use it run OAuth 2.1, with tokens issued for that one server and never passed along to another service. Local stdio servers skip OAuth and read keys from environment variables.
Warning: An MCP server inherits every permission its API key has. Wrap a full-access key and the model can delete whatever that key can. Give the server its own read-only key, then add write tools one at a time.
Prompt injection is the bigger worry. A web page or email the model reads can tell it to call a tool you never meant to run. A plain API integration can’t be talked into anything.
What changed in MCP in July 2026, and who supports it?
MCP now behaves much more like an ordinary web API. The 2026-07-28 spec, the current version, dropped sessions and the start-up handshake, so every request stands on its own.
A remote server used to need sticky sessions and a shared session store. Now any request can hit any instance behind a plain load balancer, just like REST.
The release also added cache hints on tool lists, routing headers like Mcp-Method and a 12-month deprecation window.
Anthropic open-sourced MCP in November 2024 and gave it to the Linux Foundation’s Agentic AI Foundation in December 2025. OpenAI, Google, Microsoft, AWS and Cloudflare sit on its top tier.
Claude, ChatGPT, Gemini, Copilot, Cursor and VS Code all use MCP. The official SDKs see close to half a billion downloads a month.
So should you build an MCP server or just use the API?
Use the API when your code knows what to call. Add MCP when an AI app should work out the calls.

- Who decides the call
- Your code
- Works without an AI model
- Yes
- Bytes per call in our test
- 400
- Context cost per tool, every message
- None
- Standard auth
- Whatever the API chose
- Who decides the call
- The model
- Works without an AI model
- No
- Bytes per call in our test
- 1,016
- Context cost per tool, every message
- 65 to 365 tokens in our test
- Standard auth
- OAuth 2.1 remote, env vars local
We may earn a commission when you buy through links on this page. This does not affect our reviews.
Stick with the API if you’re building an app, script or automation and you know the steps. A nightly job syncing orders to a spreadsheet gains nothing from a model choosing calls. It only adds tokens and risk.
Add an MCP server if people want your service inside Claude, ChatGPT or Cursor, or your agent needs several tools. If you already have a REST API, it’s a wrapper, not a rebuild: our first tool took 12 lines.
Run both if you sell a product. Keep the API as the source of truth for your app and partners. Put a small, read-only MCP server in front of it for AI users.
How to put MCP on top of an API you already have
Start small. Three read-only tools beat thirty that mirror every endpoint.
From API to MCP server
The order we'd follow after this test.
-
Step 1 of 5
Pick the 3 to 5 jobs people actually ask for
Not every endpoint. “Find a post” and “count posts by category” are tools. Pagination cursors and admin settings aren’t.
-
Step 2 of 5
Write descriptions for a model, not a developer
One plain sentence per tool on what it does and when to use it. The model chooses from this text, so vague wording means wrong calls.
-
Step 3 of 5
Return compact results
Drop fields the model doesn’t need. Our pretty-printed posts cost 53% more tokens than the same compact JSON.
-
Step 4 of 5
Use a scoped, read-only key
Give the MCP server its own API key with the least access that works. Add write tools later, behind the app’s approval prompt.
-
Step 5 of 5
Test with MCP Inspector before any AI app
The official Inspector lists your tools and calls them by hand, so you can tell a server bug from a model mistake.
Rather not write code? n8n can publish a workflow as an MCP server with its MCP Server Trigger node. The API calls you’ve already built become tools an AI app can use.
For the opposite direction, an agent calling tools, see our n8n AI agent tutorial.
Affiliate note: the n8n link above pays us a commission if you subscribe, and your price stays the same. We’d recommend the same node without it.
Frequently asked questions
Will MCP replace REST APIs?
No. Almost every MCP server calls an API underneath, so MCP depends on APIs rather than replacing them. APIs will keep serving apps, scripts and partners with no AI model involved. MCP adds a layer for AI apps on top, much like a mobile SDK sits on top of a web API.
Is MCP vs API the same debate as function calling vs API?
Close, but not quite. Function calling is a model feature: you describe functions in one provider’s request format and the model asks to call them. MCP standardises how tools are listed and called. One server then works across Claude, ChatGPT, Gemini and Cursor, with no rewrite per provider.
Can an MCP server wrap a GraphQL or SOAP API?
Yes. MCP doesn’t care what’s behind a tool. The server receives a tools/call request and can run a GraphQL query, a SOAP call, a database query or a script. The model only sees the tool’s name, description and result, never the backend’s format.
Can I turn an OpenAPI spec into an MCP server automatically?
Yes, open-source generators do it, but check what comes out. Most make one tool per endpoint, and every tool adds tokens to each message. A hand-picked set of 3 to 5 tools with model-friendly descriptions usually beats a 60-tool dump.
Can I rate limit and bill MCP calls like API calls?
Yes. A remote MCP server is an HTTP endpoint, so rate limits, quotas and usage billing work the same way. The July 2026 spec helps: the method and tool name now travel in Mcp-Method and Mcp-Name headers. A gateway can meter per tool without parsing the body.
Is an MCP server the same as an API gateway?
No. A gateway routes, secures and meters API traffic, but it doesn’t describe tools for a model. An MCP server turns an API into model-readable tools. Many teams run both, with the gateway in front of the MCP server handling auth, rate limits and logging.
Does a SaaS product need an MCP server in 2026?
Only if customers want to use it from AI apps. If buyers already ask Claude or ChatGPT to pull reports or create records, build one. A small read-only server on your existing API is cheap. If nobody’s asking, your API and docs matter more.
The bottom line
MCP vs API isn’t a fight. The API does the work; MCP describes that work so an AI model can choose it.
If your code knows the steps, call the API. If you want Claude, ChatGPT or Cursor to use your service, wrap a few read-only endpoints in MCP. Either way, watch the tool list, because that’s where the tokens go.
Next step: pick one API you already use and list three jobs you’d hand an AI. Those are your first MCP tools.



