An API is a contract that one program uses to talk to another. MCP, the Model Context Protocol, is a standard way for an AI model to find out what a service can do and then ask for it. So MCP vs API is not a choice between two things. An MCP server usually sits on top of an API and makes it usable by an AI agent.
I learned this the practical way. This month I built 20 MCP servers for Google services, from Gmail to Google Analytics. Every one of them wraps a Google API that already existed. Below is what the MCP layer added, what it did not, and how to decide which one you need.
MCP vs API at a glance
| API | MCP server | |
|---|---|---|
| Who calls it | Code a developer wrote | An AI model, through an app such as Claude Code, Cursor or VS Code |
| How the caller learns what it can do | A developer reads the docs | The model asks the server at run time (tools/list) |
| Descriptions written for | People | The model, in plain language, with a JSON Schema for every input |
| Message format | Anything: REST, GraphQL, gRPC, SOAP | Always JSON-RPC 2.0 |
| One integration works with | The one app you wrote it for | Every app that speaks MCP |
| Who approves each action | Your code decides | The user, through the host app |
| Best for | Apps and services talking to each other | Giving an AI agent tools and data |
What an API is
An API (application programming interface) is the set of requests a service accepts and the answers it returns. The Google Analytics Data API, for example, takes a request for a report and sends back rows of numbers. A developer reads the documentation, writes code against it, handles the sign-in and the errors, and ships an app.
That model works well when a person decides in advance exactly which calls the app makes. It is how almost all software talks today, and nothing about MCP changes that.
What MCP is
MCP is an open protocol that Anthropic announced on November 25, 2024. The current specification defines three roles:
- Host: the AI app you use, such as Claude Code, Cursor or VS Code with Copilot.
- Client: the connector inside the host that talks to one server.
- Server: the program that offers capabilities to the model.
A server can offer three kinds of things:
- Tools: functions the model can run, such as “run a GA4 report” or “send an email”.
- Resources: data the model or the user can read, such as a file or a record.
- Prompts: ready-made message templates the user can pick.
Every message is JSON-RPC 2.0. A server runs either on your machine, where the app starts it and talks to it over standard input and output, or on the web over HTTP.
A real example: one GA4 report, two ways
Say you want the top 10 pages by sessions for the last 7 days.
Through the API
You write code that signs in with Google, then sends this to https://analyticsdata.googleapis.com/v1beta/properties/371242449:runReport:
{
"dateRanges": [{ "startDate": "7daysAgo", "endDate": "today" }],
"dimensions": [{ "name": "pagePath" }],
"metrics": [{ "name": "sessions" }],
"limit": 10
}You had to know the endpoint, the field names, the property ID and how to sign in. If you want a different report tomorrow, you change the code.
Through MCP
You type “top 10 pages by sessions, last 7 days” into Claude Code. First, the app asks my GA4 MCP server what it can do (tools/list). The server answers with a list of tools. One of them looks like this in my source code:
server.tool(
'run_report',
'Runs a Google Analytics 4 Data API report.',
{
property_id: z.union([z.string(), z.number()]).describe('GA4 property ID'),
date_ranges: z.array(z.object({ start_date: z.string(), end_date: z.string() })),
dimensions: z.array(z.string()).describe('Dimension names'),
metrics: z.array(z.string()).describe('Metric names'),
limit: z.number().optional(),
},
...
);The model reads that description, fills in the inputs itself and sends a tools/call request:
{
"jsonrpc": "2.0",
"id": 7,
"method": "tools/call",
"params": {
"name": "run_report",
"arguments": {
"property_id": "371242449",
"date_ranges": [{ "start_date": "7daysAgo", "end_date": "today" }],
"dimensions": ["pagePath"],
"metrics": ["sessions"],
"limit": 10
}
}
}The server turns that into the same Data API call you saw above and returns the rows. Real requests carry a little more metadata, but that is the whole idea. Notice that nobody wrote code for this particular report. Tomorrow you can ask for bounce rate by country and the same tool handles it.
What MCP adds on top of an API
- Discovery at run time. The model asks the server what it can do, every time. Add a tool to the server and every connected app sees it without an update.
- Descriptions written for a model. Each tool explains itself in plain language, and each input has a JSON Schema. That is what lets the model pick the right tool and fill it in correctly.
- One integration works in many apps. My Gmail MCP server works in Claude Code, Cursor, VS Code Copilot and several other agents. A plain API integration would have to be written once per app.
- The user stays in charge. The specification says the host must get your consent before it runs a tool. In practice, your AI app asks before it sends an email or changes a campaign. I went further in my servers, so anything destructive also needs an explicit
confirm: true. - A standard for signing in. HTTP servers follow an OAuth-based authorization framework defined in the spec. Local servers read their credentials from your machine instead.
What MCP does not do
- It does not replace the API. Every one of my 20 servers calls a Google API underneath. If the API does not offer something, the MCP server cannot either.
- It does not remove API setup. You still need the Google Cloud project, the OAuth client and, for Google Ads, a developer token. Quotas and rate limits still apply.
- It is not free in tokens. Every tool description goes into the model’s context. A server with 40 tools costs context before you ask anything, so good servers keep the list short and clear.
- It is not for app-to-app traffic. If your backend needs to sync orders every hour, call the API directly. There is no model in that loop, so MCP adds nothing.
- It does not make a server trustworthy. The spec treats tool descriptions from an unknown server as untrusted. Install MCP servers the way you install browser extensions, from sources you trust.
MCP vs API: when to use each
Use the API directly when:
- You know exactly which calls you need and they do not change.
- The caller is your own code, a cron job or another service.
- Speed and cost per call matter more than flexibility.
Use an MCP server when:
- An AI agent should decide which calls to make, from a request in plain language.
- You want the same tools in several AI apps without writing each integration again.
- A person should approve actions as they happen.
Many teams end up with both, which is how it should be. In my own MCP vs API setup, the MCP servers are a thin, careful layer over APIs that keep doing the real work.
Common questions
Does MCP connect to APIs?
Yes, almost always. An MCP server is usually a wrapper around one or more APIs. It receives a request from the model, calls the API and returns the result in a form the model can use.
Is MCP replacing APIs?
No. MCP depends on them. It changes who calls the API. A model makes the calls instead of hand-written code, and the API still does the work.
What is the difference between an MCP server and a REST API?
A REST API is designed for developers, who read its documentation and write code against it. An MCP server is designed for AI models, which ask it what it can do and call it on their own. Many MCP servers call a REST API underneath.
Is an MCP server the same as an API gateway?
No. An API gateway sits in front of APIs to route, secure and meter traffic between services. An MCP server translates between a model and an API. A company can put a gateway in front of its MCP servers too.
Does ChatGPT use MCP?
Yes. According to OpenAI’s help center, ChatGPT can connect to remote MCP servers (on Business, Enterprise and Edu plans as of November 2026), and OpenAI’s API accepts remote MCP servers as tools. Servers that run on your own machine need a tunnel to reach ChatGPT.
What is the difference between the Claude API and MCP?
The Claude API is how your code sends a prompt to the model and gets an answer back. MCP is how the model, inside an app like Claude Code, reaches out to tools and data. You can use either one without the other.
Try it with a real MCP server
The fastest way to feel the difference is to install one MCP server and ask it something in plain language. All 20 of mine are free, run on your machine and use your own Google account. Start with the Google MCP servers list, or go straight to Google Analytics MCP to try the example above.