Skip to content

Guide7 min readPublished

MCP vs API: does a store with an API need MCP?

An API serves a developer’s code; an MCP server lets an AI model find and call your store’s actions by itself. What Shopify’s move to UCP shows about the two, and when a store needs a server of its own.

Shopify has taken the catalog and cart tools off its stores' MCP address, and its migration page puts the instruction in one line: "Use the Universal Commerce Protocol (UCP) instead." For a store owner who had only just learned what MCP stood for, that can look like permission to forget it again. Shopify still serves MCP, though, at a new address, and why it moved says a lot about how MCP and an ordinary API relate.

An API is how a developer's program talks to your store. An MCP server is how an AI application talks to it: the model asks the server which tools it offers, reads their descriptions, and decides which to call. If your store has an API, an MCP server usually sits on top of it and calls the same endpoints, with descriptions a model can use without a developer in between.

So does a store with an API still need one? Some do, and many will get one from their platform without writing a line of code.

What is the difference between MCP and an API?

The MCP project calls itself "an open-source standard for connecting AI applications to external systems", and offers an analogy: "Think of MCP like a USB-C port for AI applications." The specification is more precise. It uses JSON-RPC 2.0 messages between "Hosts: LLM applications that initiate connections", clients inside those hosts, and "Servers: Services that provide context and capabilities". As of November 2026, the current version is dated 2026-07-28.

The practical differences show up when you ask the same question of both. Pick one:

A store’s API and an MCP server, one question at a time
The question

Showing: Who calls it

A REST API

A program a developer wrote for your API: an app, an integration, a script.

An MCP server

An AI application. The specification calls it the host, “LLM applications that initiate connections”, with a client inside it for each server.

Our reading

The difference is who reads your documentation. For an API, a developer reads it once. For MCP, the model reads the tool list each time it connects.

Sources: MCP specification 2026-07-28 and Model Context Protocol: Architecture overview

“Our reading” lines are ours. The quotes come from the MCP site and specification (2026-07-28), RFC 9727 and Shopify’s docs, read on 4 November 2026.

Look at who decides which call to make. With your API, a developer decides, in code, weeks before any customer arrives. With MCP, the model decides at the moment it is helping someone: "Tools in MCP are designed to be model-controlled, meaning that the language model can discover and invoke tools automatically based on its contextual understanding and the user's prompts."

That changes what your documentation is for. An API reference is read by a person who can email you when it is unclear. A tool description is read by a model that will not email anyone; it picks a tool, or picks the wrong one, or gives up.

Does an MCP server replace a store's API?

Usually it calls it. MCP's architecture page describes tools as "Executable functions that AI applications can invoke to perform actions (e.g., file operations, API calls, database queries)". For a store, the API call is the common case: an MCP tool called search_products runs the same search your API already offers and hands the results back in MCP's format.

You can see the wrapping for yourself. Describe one of your endpoints and the builder writes the tool definition a server would list for it:

Turn one API endpoint into the MCP tool an agent would see
Your API endpoint’s method
Your server still calls: GET /api/products/search?query=…&max_price=…&in_stock_only=…
{
  "tools": [
    {
      "name": "search_products",
      "description": "Search the store’s products by keyword and return name, price, stock and a link for each.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string"
          },
          "max_price": {
            "type": "number"
          },
          "in_stock_only": {
            "type": "boolean"
          }
        },
        "required": [
          "query"
        ],
        "additionalProperties": false
      }
    }
  ]
}

  • Fine: The name keeps to the specification’s rule: 1 to 128 letters, digits, _ - or .
  • Fine: The description says what the tool does. The model reads it to choose the tool.
  • Fine: Every parameter line reads as a name, a type and an optional “required”.

Nothing you type leaves the page, and the endpoint is never called. The checks on the name follow the specification’s “SHOULD” rules; the one on the description is our advice.

Source: MCP specification 2026-07-28: Tools

The specification has rules for the name, which "SHOULD be between 1 and 128 characters" and "SHOULD NOT contain spaces, commas, or other special characters". It has no rule for writing a good description, which is the part that decides whether a model ever calls your tool. Ours is plain: say what it does and what it returns, in the words a shopper would use.

How does an AI agent find out what your API can do?

An API is found through documentation or a catalogue. RFC 9727 defines /.well-known/api-catalog, "intended to facilitate automated discovery and usage of published Application Programming Interfaces (APIs)". A catalogue points a program at your APIs, and a developer still has to write the code that uses them.

With MCP, the agent asks the server. "To discover available tools, clients send a tools/list request", and each tool in the answer carries a name, a description and an inputSchema describing its parameters. Here is that request, ready to try against a server:

An MCP request builder: a tools/list or tools/call to try on a server
Method
curl -X POST 'https://shop.example.com/mcp' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2026-07-28' \
  -H 'Mcp-Method: tools/list' \
  --data '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientInfo": {
        "name": "ExampleClient",
        "version": "1.0.0"
      },
      "io.modelcontextprotocol/clientCapabilities": {}
    }
  }
}'

  • Yes: The endpoint is an https URL

What a server must answer when the request is wrong:

  • The MCP-Protocol-Version header and the body’s protocolVersion differ, or a required header is missing400 Bad Request, JSON-RPC error -32020 HeaderMismatch
  • The server does not implement the requested protocol version400 Bad Request with UnsupportedProtocolVersionError, listing its versions
  • The server does not implement the method404 Not Found, JSON-RPC error -32601 (Method not found)
  • An Origin header is present and invalid403 Forbidden

Source: MCP specification 2026-07-28: Streamable HTTP

This discovery at runtime is what MCP adds. An agent that has never heard of your store can connect, read the list and act, with no developer reading anything first. You still decide whether it may act. The transport "supports standard HTTP authentication methods including bearer tokens, API keys, and custom headers", and Shopify's Checkout MCP says "All requests require authentication or a signed request."

Why did Shopify move its MCP tools to UCP?

Shopify's page states the change rather than the reasons: "The catalog and cart tools on https://{shop}/api/mcp were removed. Use the Universal Commerce Protocol (UCP) instead." It then adds that "UCP now provides these capabilities at https://{shop}/api/ucp/mcp", and its Checkout MCP page says "Checkout MCP implements the UCP checkout capability (dev.ucp.shopping.checkout)."

Shopify still speaks MCP to agents, at a new address, with JSON-RPC requests that must carry an agent profile ("Include meta["ucp-agent"] with a profile URI"). What changed is who defines the tools. Before, Shopify chose its own tool names; now UCP, a shared commerce protocol, defines which tools a shop offers and what they do. We think that is where store MCP servers are heading: MCP as the wire, a commerce protocol for the vocabulary, so an agent does not have to learn every shop's homemade tool names. UCP explained covers the protocol, and UCP vs ACP vs MCP vs AP2 puts the four side by side.

Which MCP and API files do our checks look for?

It looks for three things on this topic, all from the outside. DISC-011 checks for an RFC 9727 API catalogue. DISC-012 checks for an MCP server card, a small file that describes your server before an agent connects (a draft proposal, not yet part of the MCP specification). TRX-013 runs only when your UCP profile names an MCP endpoint: it sends one tools/list request and compares the tools against the ones UCP expects for the capabilities you declare. None of them calls a tool, and none of them needs your API keys.

Frequently asked questions

Is MCP an API?

In a loose sense, yes: it is a protocol for one program to call another. In practice the term means something narrower. MCP is a standard way for an AI application to discover and call tools, and those tools usually call your ordinary API underneath.

Do I need an MCP server if I have a REST API?

Not necessarily. If AI agents only ever reach you through a platform that speaks for you, such as Shopify through UCP, the platform runs the server. If you want any agent to find and use your store's actions without a developer integrating first, an MCP server is how that works today.

Can an MCP server use my existing API?

Yes, and it usually does. MCP describes tools as functions that perform actions such as "API calls", so a store's server is mostly a thin layer that calls the API you already have.

Is MCP secure for a store?

It is as secure as you make it. The HTTP transport supports bearer tokens, API keys and OAuth, and the specification says there "SHOULD always be a human in the loop with the ability to deny tool invocations." Shopify requires authentication or a signed request for every checkout call.

What did Shopify replace Storefront MCP with?

UCP's tools on https://{shop}/api/ucp/mcp: catalogue search and lookup, carts, checkout, and an ask_business tool for policy questions, according to Shopify's migration page.

Which do you need?

What we would do, by situation:

Your situationWhat to do
On Shopify, no custom appNothing to build. Shopify serves UCP's MCP tools for you.
Another platform with an MCP optionCheck its status label, then turn it on and keep it on the shared protocol's tools. The MCP server guide lists the platforms.
Your own API, and developersWrap your search, cart and checkout endpoints as MCP tools, ideally using UCP's names, and describe each one as if to a new colleague.
No API at allFix the pages first. Agents that cannot use tools read your product pages and checkout, which the reasons agents give up on a store walks through.

Whichever row you are in, it helps to know whether an agent gets as far as your API at all. Once you run our agent readiness checker, the MCP question usually shrinks.

The sources below were last checked on the date shown.