# 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.

By Valerii Checha, 19 Nov 2026

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.

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](https://modelcontextprotocol.io/specification/2026-07-28) and [Model Context Protocol: Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture).

How the caller finds out what it can do. A REST API: From your docs, or from a catalog: RFC 9727 defines /.well-known/api-catalog “to facilitate automated discovery and usage of published Application Programming Interfaces (APIs)”. An MCP server: It asks the server: “To discover available tools, clients send a tools/list request.” Each tool comes back with a name, a description and an inputSchema. Our reading: An API catalog points to your APIs. An MCP tool list describes each action in words a model can act on.

Sources: [RFC 9727: api-catalog](https://www.rfc-editor.org/rfc/rfc9727) and [MCP specification 2026-07-28: Tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools).

Who decides which call to make. A REST API: The developer, in code, before anyone runs it. An MCP server: “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.” Our reading: So your tool descriptions do the job your API docs did. A vague description gets the wrong tool picked, or none.

Source: [MCP specification 2026-07-28: Tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools).

What it runs underneath. A REST API: Your own code: the catalogue, the cart, the order system. An MCP server: Tools are “Executable functions that AI applications can invoke to perform actions (e.g., file operations, API calls, database queries)”. Our reading: An MCP server for a store usually calls the store’s existing API. It is a second front door to the same rooms.

Source: [Model Context Protocol: Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture).

Who is allowed in. A REST API: Whatever your API already uses: keys, OAuth, signed requests. An MCP server: The HTTP transport “supports standard HTTP authentication methods including bearer tokens, API keys, and custom headers. MCP recommends using OAuth to obtain authentication tokens.” Shopify’s Checkout MCP: “All requests require authentication or a signed request.” Our reading: Either way, you decide which callers get in. Adding MCP does not make that decision for you.

Sources: [Model Context Protocol: Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture) and [Shopify: Checkout MCP server](https://shopify.dev/docs/agents/carts-and-checkout/checkout-mcp).

What Shopify did. A REST API: Outside this change: Shopify’s migration page covers the catalog and cart tools that lived on /api/mcp. An MCP server: “The catalog and cart tools on https\://{shop}/api/mcp were removed. Use the Universal Commerce Protocol (UCP) instead.” “UCP now provides these capabilities at https\://{shop}/api/ucp/mcp.” Our reading: Shopify still speaks MCP to agents, through UCP’s tools on a new address. A protocol on top of MCP decides which tools a shop offers.

Sources: [Shopify: Migrate from Storefront MCP](https://shopify.dev/docs/apps/build/storefront-mcp) and [Shopify: Checkout MCP server](https://shopify.dev/docs/agents/carts-and-checkout/checkout-mcp).

“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.

On the page, you describe one API endpoint (method, path, tool name, description and parameters) and get the MCP tool definition a server would list for it. Nothing is sent. The example: GET /api/products/search, which your server still calls as GET /api/products/search?query=…\&max_price=…\&in_stock_only=…. The tool definition:

```json
{
  "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”.

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.

On the page, you choose tools/list or tools/call, the server address, the tool name and its arguments, and copy the request as a curl command. A tools/list:

```sh
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": {}
    }
  }
}'
```

A tools/call:

```sh
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/call' \
  -H 'Mcp-Name: search_catalog' \
  --data '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search_catalog",
    "arguments": {
      "catalog": {
        "query": "linen shirt"
      }
    },
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientInfo": {
        "name": "ExampleClient",
        "version": "1.0.0"
      },
      "io.modelcontextprotocol/clientCapabilities": {}
    }
  }
}'
```

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 missing: 400 Bad Request, JSON-RPC error -32020 HeaderMismatch.
- The server does not implement the requested protocol version: 400 Bad Request with UnsupportedProtocolVersionError, listing its versions.
- The server does not implement the method: 404 Not Found, JSON-RPC error -32601 (Method not found).
- An Origin header is present and invalid: 403 Forbidden.

Source: [MCP specification 2026-07-28: Streamable HTTP](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/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](https://storewalk.ai/blog/ucp-explained) covers the protocol, and [UCP vs ACP vs MCP vs AP2](https://storewalk.ai/blog/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](https://storewalk.ai/checks/DISC-011) checks for an RFC 9727 API catalogue. [DISC-012](https://storewalk.ai/checks/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](https://storewalk.ai/checks/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 situation                      | What to do                                                                                                                                                                                          |
| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| On Shopify, no custom app           | Nothing to build. Shopify serves UCP's MCP tools for you.                                                                                                                                           |
| Another platform with an MCP option | Check its status label, then turn it on and keep it on the shared protocol's tools. The [MCP server guide](https://storewalk.ai/guides/add-an-mcp-server-to-your-store) lists the platforms.        |
| Your own API, and developers        | Wrap 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 all                       | Fix the pages first. Agents that cannot use tools read your product pages and checkout, which [the reasons agents give up on a store](https://storewalk.ai/blog/why-agents-cant-buy) 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](https://storewalk.ai/), the MCP question usually shrinks.

The sources below were last checked on the date shown.

## Sources

- [Model Context Protocol: What is MCP?](https://modelcontextprotocol.io/docs/getting-started/intro)
- [Model Context Protocol: Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture)
- [MCP specification 2026-07-28](https://modelcontextprotocol.io/specification/2026-07-28)
- [MCP specification 2026-07-28: Tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)
- [RFC 9727: api-catalog](https://www.rfc-editor.org/rfc/rfc9727)
- [Shopify: Migrate from Storefront MCP](https://shopify.dev/docs/apps/build/storefront-mcp)
- [Shopify: Checkout MCP server](https://shopify.dev/docs/agents/carts-and-checkout/checkout-mcp)

Last checked 4 Nov 2026
