MCP vs REST APIs
A REST API is a service's own interface: many URLs and HTTP methods, designed for programs that a developer writes after reading the documentation. The Model Context ProtocolModel Context Protocol (MCP): An open protocol that lets AI applications discover and use tools, data and prompt templates from separate servers through one standard set of JSON-RPC messages. (MCP) is one fixed interface for AI applications: a client asks any server "which tools do you have?" (tools/list) and "run this one with these arguments" (tools/call), and gets back descriptions written for a model. They are not rivals. Many MCP servers that talk to a SaaS product call its REST API underneath. The real choice for an agent is how it reaches that API: through a generic HTTP tool, through a narrow tool you wrap yourself, or through an MCP server.
The same API, two ways in
Side by side
| Question | REST API | MCP |
|---|---|---|
| Who is it designed for? | Developers writing client code | AI applications that list and call tools at run time |
| How many operations does a caller learn? | Every endpoint, method, header and status code of that API | Two core methods for tools, the same on every server |
| How is it described? | Optionally by an OpenAPI document, usually read by developers and code generators | By tools/list at run time: a name, a description and an inputSchema per tool |
| Who reads the description? | A developer | The model, directly |
| How do errors come back? | HTTP status codes and an API-specific body | A protocol error, or a tool result with isError: true and a message the model can act on |
| How does auth work? | Whatever the API chose: API keys, OAuth, signed requests | Optional; for HTTP servers, an OAuth 2.1 based flow the spec defines; for local stdio servers, credentials from the environment |
| How does a caller learn about changes? | Release notes and version numbers | notifications/tools/list_changed from servers that declare listChanged (from 2026-07-28, to clients that subscribe) |
| What carries it? | HTTP | JSON-RPC 2.0 over stdio or Streamable HTTP |
The OpenAPI Specification calls itself "a standard, language-agnostic interface to HTTP APIs which allows both humans and computers to discover and understand the capabilities of the service". That is close to what MCP's tools/list does. The difference is the reader and the moment. An OpenAPI document describes every operation of an API for code generators and developers. An MCP tool list is a short menu, written for a model, served at the moment the agent needs it.
Why not let the agent call the REST API directly?
You can give a model a tool such as http_request(method, url, headers, body) and point it at any API. It works in a demo. In production, four things go wrong.
- The action surface is the whole API. A generic HTTP tool lets the model call any endpoint with any method. A
DELETEis one token away from aGET. With an MCP server, or a narrow tool you write, the model can only callsearch_ticketsandcreate_ticket, and each has a schema that can reject extra fields. - The credential has to go somewhere. If the model builds the headers, the API key ends up in its context or in its tool arguments, where traces and logs can capture it. With MCP, the server or the host holds the credential (the host for an OAuth token, the server for the key to the API behind it); the model never sees it. See OAuth vs API keys for MCP.
- Any URL is reachable. A tool that fetches whatever URL the model writes is a request-forgery risk: a prompt injection in a document can steer it to an internal address or to an attacker's server with your data in the query string. See SSRFSSRF: Server-side request forgery: making a server fetch a URL the attacker chose, such as an internal service or a cloud metadata address, from inside the network. and the lethal trifecta.
- The model reads API docs badly at run time. Long endpoint lists, pagination rules and status codes cost tokens and invite wrong calls. A few well-named tools with short descriptions work better. See Too many tools.
None of this needs MCP specifically. A hand-written function with a fixed URL and a narrow schema solves the same problems. MCP adds that the narrow tool is packaged once, as a server, and every MCP-capable app can use it.
When a plain HTTP call is the better choice
Not every API call needs a model to decide it, and not every call needs a protocol.
- The call is fixed. "When a form is submitted, post it to the CRM" is a workflow step. No model chooses anything, so a plain HTTP request with a reviewed URL template is simpler and cheaper.
- There is one endpoint, and it is yours. Wrapping your own internal service in an MCP server just to call one route adds a process to run and monitor.
- The data is large or binary. Moving a file between two systems is better done by a step that streams it than by a model reading it as a tool result.
- Latency matters. Every round of tool calls an agent makes costs at least one more model call to read the results. A fixed step costs none.
A good rule: if the model must decide whether and with what arguments to call, give it a narrow tool (MCP or your own function). If nothing needs deciding, use a plain HTTP step.
How they combine
The usual architecture uses both, in layers:
- An MCP server wraps a REST API. The server picks the operations an agent needs, names them clearly, writes short descriptions, holds the API credential and returns compact results. The REST API is unchanged.
- OpenAPI as a starting point. An OpenAPI document already lists operations and their parameters, and an operation's optional
operationIdmust be unique when present, so some teams generate MCP tools from it. Generate, then cut: an API with eighty operations should not become eighty tools. - Fixed calls stay plain HTTP. Steps that always happen, such as logging a result or sending a webhook, stay outside the agent.
In L2M
L2M has both paths, and keeps them apart:
- The HTTP Request node is a workflow step: a method (
GET,POST,PUT,PATCHorDELETE), a URL template, a headers template, a body template and an optional secret, which L2M sends asAuthorization: Bearer <secret>. The secret is stored encrypted and the workflow holds only a reference to it (secrets). Its URL goes through outbound URL checks, which always block cloud metadata addresses and can block private ranges. It is not attached to an agent'stoolport. Its URL template can rendervalues from earlier steps, so a model does not choose the URL unless your template puts a model's output there. - MCP Tool nodes on an agent's
toolport are the agent's tools. Register each server once in the MCP server registry, with its endpoint and credential, and pick the tools an agent may see. - A narrow tool from your own HTTP call. To let an agent decide when to call a REST endpoint without writing an MCP server, put the HTTP Request node in a small workflow and attach that workflow to the agent with a Workflow Tool node. The agent sees one tool whose arguments come from the child workflow's trigger (its input schema, or one free-text
input), and the URL and secret stay in the child. Keep the host fixed in the child's URL template: put the agent's arguments in the path, query or body, never in the host. Workflow tools are governed like MCP tools: tool rules can deny them or require approval, and each call is recorded in tool-call telemetry.
The reverse also works. An Expose as MCP Tool trigger turns a whole workflow, HTTP calls included, into an MCP tool that other agents call through the MCP gateway (workflow as an MCP tool).
Further reading
- MCP specification 2025-11-25: Tools (modelcontextprotocol.io)
- MCP specification 2025-11-25: Architecture (modelcontextprotocol.io)
- OpenAPI Specification 3.1.0 (OpenAPI Initiative)
- Related guides: What is MCP?, MCP vs function calling, MCP tools, resources and prompts