# How to add an MCP server to your store

What MCP server each platform already offers, and how to build, secure and publish your own, with a request builder, a tool planner and a server card builder.

By Valerii Checha, 3 Nov 2026

How do you add an MCP server to your store? On Shopify the platform runs one for you at `/api/ucp/mcp`, and on BigCommerce you turn on Storefront MCP in the settings. WooCommerce's official MCP is a store management tool "in developer preview", and Adobe labels its Commerce MCP "Coming Soon". Anywhere else you build one: a single HTTPS address that takes POST requests under MCP 2026-07-28, the tool names UCP defines, sign-in and rate limits, declared in your UCP profile and described in a server card.

This guide says what each platform offers, then walks through building and publishing your own, with a request builder, a tool planner and a server card builder. Storewalk is ours: we build the scan, and its [MCP check](https://storewalk.ai/checks/TRX-013) and [server card check](https://storewalk.ai/checks/DISC-012) are ours. The specifications and platforms are quoted from their own pages, read on 3 November 2026. For what MCP is and how it compares with A2A and WebMCP, read [MCP, A2A and WebMCP for stores](https://storewalk.ai/blog/mcp-a2a-webmcp-for-stores) first, and for the five walls an agent meets on the way to a sale, [the hub article](https://storewalk.ai/blog/why-agents-cant-buy).

## What does an MCP server do for a store?

It gives an AI agent named actions to run instead of pages to read. MCP, the Model Context Protocol, lets a server "expose tools that can be invoked by language models", and "Each tool is uniquely identified by a name and includes metadata describing its schema", in our words a description of the inputs it accepts. An agent asks for the list with `tools/list` and runs one with `tools/call`. For a store, the tools are things like search the catalogue, get a product, add to a basket and start a checkout. Shopify's catalog server, for example, lists `search_catalog`, `lookup_catalog` and `get_product`. A product page is written for people; a tool is a shop assistant that only speaks JSON, which agents happen to like.

## Does your platform already have an MCP server?

Probably, if you are on Shopify or BigCommerce. Choose yours:

What MCP server each platform offers, in its own words.

Shopify. Status: No status label on the pages we read. What it is: Shopify runs the server for the store. “UCP now provides these capabilities at https\://{shop}/api/ucp/mcp”, and “The catalog and cart tools on https\://{shop}/api/mcp were removed.” Where: https\://{shop}/api/ucp/mcp, POST. Who can call it: Agents. For the catalog tools, “every request must include a meta.ucp-agent.profile URL pointing to your agent’s UCP profile”. Checkout: “All requests require authentication or a signed request.” What is left for you: Nothing to build. Check that your store’s UCP profile at /.well-known/ucp lists the endpoint.

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

WooCommerce. Status: The developer docs: “currently in developer preview”. The agentic commerce page labels MCP “Beta”. What it is: Store operations through the WordPress MCP Adapter plugin: product and order abilities, “subject to WordPress and WooCommerce permissions”. Where: https\://yourstore.com/wp-json/mcp/mcp-adapter-default-server. “The WooCommerce-specific /wp-json/woocommerce/mcp endpoint was removed in WooCommerce 11.3.” Who can call it: You and your tools, signed in: “The default server requires an authenticated user with the read capability”, with a WordPress Application Password. What is left for you: It is a server for running the store, not one for shoppers’ agents. “Use a dedicated WordPress user with only the capabilities the MCP client needs.”

Sources: [WooCommerce developer docs: MCP](https://developer.woocommerce.com/docs/features/mcp/) and [WooCommerce: agentic commerce](https://woocommerce.com/agentic-commerce/).

BigCommerce. Status: No status label on the page. What it is: “Agents can search products, manage a shopping cart, and hand off to checkout”, with guests included. Where: Settings, then MCP under API and MCP: turn on Storefront MCP. “Each storefront has its own unique MCP server URL.” Who can call it: Shoppers’ agents, guests and signed-in customers. “You must be a store owner to enable MCP on a store.” What is left for you: Turn it on, accept the terms, and copy the endpoint.

Source: [BigCommerce developer docs: MCP overview](https://docs.bigcommerce.com/developer/api-reference/mcp/overview).

Adobe Commerce and Magento. Status: Adobe labels its Commerce MCP “Coming Soon”: “This feature is coming soon and is subject to change.” What it is: “The Commerce MCP for Adobe Commerce helps developers build custom agentic experiences from discovery to checkout”. Where: Not given on the page. Who can call it: Not given on the page. The page does not mention Magento Open Source. What is left for you: Until then, an MCP server is a build of your own or an extension’s.

Source: [Adobe Experience League: Commerce MCP overview](https://experienceleague.adobe.com/en/docs/commerce-learn/ai-and-agentic-commerce/commerce-mcp/commerce-mcp-overview).

Your own server. Status: MCP’s current revision: “The current protocol version is 2026-07-28”. What it is: Tools you define, served over Streamable HTTP. For a UCP store, the tools the UCP binding names. Where: One address: “The server MUST provide a single HTTP endpoint path … that supports POST.” Who can call it: Whoever you let in. “Authorization is OPTIONAL for MCP implementations”, and the transport page adds that servers “SHOULD implement proper authentication for all connections.” What is left for you: Build it, secure it, declare it in your UCP profile, and publish a server card if you want generic MCP clients to find it.

Sources: [MCP specification 2026-07-28: Streamable HTTP](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http) and [MCP: Versioning](https://modelcontextprotocol.io/specification/versioning).

On Shopify, the older address went quiet: "The catalog and cart tools on https\://{shop}/api/mcp were removed", and the tools now sit on `/api/ucp/mcp`, where a catalog request must carry the agent's UCP profile. And WooCommerce's server is for running the store rather than for shoppers. Its default server "requires an authenticated user with the read capability", signed in with a WordPress Application Password, and its abilities create and update products and read orders. Handing that to a shopper's agent would be handing over the stockroom keys. The [Shopify](https://storewalk.ai/shopify), [WooCommerce](https://storewalk.ai/woocommerce), [BigCommerce](https://storewalk.ai/bigcommerce) and [Magento](https://storewalk.ai/magento) guides cover the rest of each platform.

## How do you build your own MCP server?

Start from the transport. MCP's versioning page says "The current protocol version is 2026-07-28", and in that revision "The server MUST provide a single HTTP endpoint path (hereafter referred to as the MCP endpoint) that supports POST." The revision removed "the GET stream endpoint" and "protocol-level sessions", so every call stands alone. Each request carries its protocol version twice, in an `MCP-Protocol-Version` header and in the body's `_meta`, plus an `Mcp-Method` header that repeats the method, and for `tools/call` an `Mcp-Name` header that repeats the tool name. The client "MUST include an Accept header listing both application/json and text/event-stream".

Build a request below and copy it as a curl command. Point it at your server once it is running, or at a platform's, to see what comes back.

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

The spec also fixes how a server answers a wrong request. If the header and the body disagree, the server "MUST reject the request with 400 Bad Request and a HeaderMismatch JSON-RPC error". A method it does not implement gets "404 Not Found and a JSON-RPC error with code -32601". If you build on an MCP SDK, check that it supports the 2026-07-28 revision before you rely on it for these.

## Which tools should a store's MCP server offer?

If you sell through UCP, the ones UCP defines. UCP's MCP binding for release 2026-08-25 names 13 methods, from `create_checkout` to `get_product`, which our check groups by capability (checkout, cart, catalog search, catalog lookup and order) from their names. List the tools for each capability your UCP profile declares. The planner shows what our MCP check expects and how it grades a list that is short a few.

Which tools your server should list, and how our MCP check grades it.

On the page, you choose the UCP capabilities your profile declares and the tools your server lists, and see what our TRX-013 says. The tools it expects per capability:

- Checkout (dev.ucp.shopping.checkout): create_checkout, get_checkout, update_checkout, complete_checkout, cancel_checkout.
- Cart (dev.ucp.shopping.cart): create_cart, get_cart, update_cart, cancel_cart.
- Catalog search (dev.ucp.shopping.catalog.search): search_catalog.
- Catalog lookup (dev.ucp.shopping.catalog.lookup): lookup_catalog, get_product.
- Order (dev.ucp.shopping.order): get_order.

Examples:

- Declares Checkout, lists create_checkout, get_checkout, update_checkout, complete_checkout, cancel_checkout: PASS 100, tools/list answered with 5 tools (5 of 5 the UCP spec defines for the declared capabilities).
- Declares Checkout, lists create_checkout, get_checkout, update_checkout, complete_checkout: PASS 80, tools/list answered with 4 tools, 4 of 5 the UCP spec defines for the declared capabilities; missing cancel_checkout.
- Declares Checkout and Catalog search, lists create_checkout, get_checkout, search_catalog: WARN 50, tools/list answered with 3 tools, 3 of 6 the UCP spec defines for the declared capabilities; missing update_checkout, complete_checkout, cancel_checkout.

* Your UCP profile declares no MCP endpoint: SKIPPED: we send nothing.
* The server answers with a JSON-RPC error: WARN, score 50.
* It answers 404 or 410, or with something that is not JSON-RPC: FAIL.
* It answers 401, 403, 429 or 5xx, times out, or redirects: SKIPPED.

Source: [UCP 2026-08-25: MCP binding (mcp.openrpc.json)](https://ucp.dev/2026-08-25/services/shopping/mcp.openrpc.json).

A few rules from MCP's tools page shape the details:

- Names: "Tool names SHOULD be between 1 and 128 characters in length (inclusive)", using letters, digits, underscore, hyphen and dot.
- Baskets: MCP has no sessions, so a server that keeps a shopping cart across calls "should do so by returning an explicit handle", an ID the agent passes back each time. Without sign-in, the handle "should be generated with sufficient entropy (e.g., a UUIDv4) and given a bounded lifetime", and the tool description should say how long, for example "baskets expire after 24 hours of inactivity".
- Who sees what: the tool list "MAY vary by the authorization presented on the request", so a signed-in agent can see order tools that a guest does not.

## How do you keep an MCP server safe?

MCP's tools page says servers "MUST: Validate all tool inputs · Implement proper access controls · Rate limit tool invocations · Sanitize tool outputs". The transport page adds that servers "MUST validate the Origin header on all incoming connections to prevent DNS rebinding attacks" and answer an invalid one with "HTTP 403 Forbidden", and that they "SHOULD implement proper authentication for all connections". MCP itself says "Authorization is OPTIONAL for MCP implementations"; where an HTTP server does use it, "MCP servers MUST implement OAuth 2.0 Protected Resource Metadata", which [why agents stall at checkout](https://storewalk.ai/blog/why-agents-stall-at-checkout) explains.

In practice, for a store, we would add our own rules. Keep payment out of the server and hand the buyer a checkout link instead, the way Shopify's Checkout MCP does with its `continue_url`. Do not put secrets or personal data in `x-mcp-header` parameters: MCP says sensitive parameters "SHOULD NOT" be marked that way, "as header values are visible to network intermediaries". And keep a catalogue tool from returning anything your public product page does not show. The [bot protection guide](https://storewalk.ai/guides/bot-protection-without-blocking-ai-agents) covers telling a well-behaved agent from a scraper at the door.

## How do agents find your MCP server?

Two ways, and you can use both. A UCP agent reads your profile at `/.well-known/ucp`, where a service entry with `"transport": "mcp"` and an `endpoint` gives the address. A generic MCP client looks for a server card. Cards come from SEP-2127, marked "Final" on MCP's site, which says "Cards themselves can be hosted at any unreserved URI, with /server-card reserved as the recommended location". The extension's own repository still opens with "Status: Experimental", so the two labels disagree for now. Build a card here:

An MCP server card builder.

On the page, you fill in the name, version, description and server address. For an invented store:

```json
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json",
  "name": "com.example/shop",
  "version": "1.0.0",
  "description": "Search Northwind Linen’s catalogue and build a basket.",
  "remotes": [
    {
      "type": "streamable-http",
      "url": "https://shop.example.com/mcp",
      "supportedProtocolVersions": [
        "2026-07-28"
      ]
    }
  ]
}
```

- Yes: The name is reverse-DNS with exactly one slash, such as com.example/shop (schema).
- Yes: A version is set (schema).
- Yes: The description is 1 to 100 characters, now 54 (schema).
- Yes: The remote URL is an http or https address (schema).
- Yes: Name, version and description are filled in, the card shape our DISC-012 accepts.

SEP-2127's recommended place for this card: https\://shop.example.com/mcp/server-card. Where our DISC-012 looks, in order: https\://shop.example.com/.well-known/mcp/server-card.json, https\://shop.example.com/.well-known/mcp.json.

Sources: [MCP SEP-2127: Server Cards](https://modelcontextprotocol.io/seps/2127-mcp-server-cards) and [MCP server card extension: schema.ts](https://github.com/modelcontextprotocol/ext-server-card/blob/main/schema.ts).

A card is public by design: "servers MUST NOT include credentials, internal network topology, proprietary logic, or user/session-specific data", and "Wide-open CORS (Access-Control-Allow-Origin: \*) is acceptable". It describes the server and leaves out the tools, which an agent asks the server for. Cards are "optional and additive", so a server without one still works for a client that already has its address.

## What do our checks read?

[TRX-013](https://storewalk.ai/checks/TRX-013) asks your MCP server for its tools once per scan, with one `tools/list` POST in the 2026-07-28 form shown above, and only when your UCP profile declares an MCP endpoint. It passes a list that has every tool UCP defines for your declared capabilities, and grades a shorter list by the share it has, never below 40. A JSON-RPC error warns, a 404 or an answer that is not JSON-RPC fails, and a refusal (401, 403, 429), a server error or a redirect makes it skip. [DISC-012](https://storewalk.ai/checks/DISC-012) looks for a server card. [DISC-007](https://storewalk.ai/checks/DISC-007) looks for agent commerce discovery documents, your UCP profile among them.

Our checks have gaps of their own:

- DISC-012 looks for the card at `/.well-known/mcp/server-card.json`, then `/.well-known/mcp.json`, which are older draft paths, and not at SEP-2127's `<streamable-http-url>/server-card`. When it finds no card but your UCP profile declares an MCP server, it warns rather than fails. Until our check catches up, a copy of the card at the first path keeps both readers happy.
- DISC-007 still counts a 405 or 400 answer at Shopify's older `/api/mcp` address as an MCP endpoint, though Shopify says the catalog and cart tools there were removed.
- TRX-013 reads tool names only. Whether a tool works when called is beyond a check that sends one request and never buys anything.

## Frequently asked questions

### Do I need an MCP server to sell through AI agents?

No. Agents can read your product pages and use your checkout like a visitor. An MCP server gives them tools instead, and on Shopify and BigCommerce the platform provides it. See the [agent readiness checklist](https://storewalk.ai/guides/agent-readiness-checklist) for where it sits among the other tasks.

### What is the current MCP version?

2026-07-28. MCP's versioning page says "The current protocol version is 2026-07-28".

### Where is Shopify's MCP endpoint?

At `https://{shop}/api/ucp/mcp`. Shopify says "UCP now provides these capabilities at https\://{shop}/api/ucp/mcp" and that the catalog and cart tools on `/api/mcp` were removed.

### Is WooCommerce's MCP for shoppers' agents?

Not as documented. WooCommerce says its MCP "is currently in developer preview", and its default server "requires an authenticated user with the read capability". It is a way for you and your tools to manage the store.

### Where should I publish an MCP server card?

SEP-2127 recommends `<streamable-http-url>/server-card`, the MCP address with `/server-card` added. Our DISC-012 reads `/.well-known/mcp/server-card.json` and `/.well-known/mcp.json` today, so serving the same card at the first of those as well covers both.

The sources below were last checked on the date shown.

## Sources

- [MCP: Versioning](https://modelcontextprotocol.io/specification/versioning)
- [MCP specification 2026-07-28: Streamable HTTP](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http)
- [MCP specification 2026-07-28: Tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)
- [MCP specification 2026-07-28: Authorization](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization)
- [MCP SEP-2127: Server Cards](https://modelcontextprotocol.io/seps/2127-mcp-server-cards)
- [MCP server card extension: README](https://github.com/modelcontextprotocol/ext-server-card/blob/main/README.md)
- [MCP server card extension: schema.ts](https://github.com/modelcontextprotocol/ext-server-card/blob/main/schema.ts)
- [UCP 2026-08-25: MCP binding (mcp.openrpc.json)](https://ucp.dev/2026-08-25/services/shopping/mcp.openrpc.json)
- [Shopify.dev: Storefront MCP](https://shopify.dev/docs/apps/build/storefront-mcp)
- [Shopify.dev: Storefront Catalog](https://shopify.dev/docs/agents/catalog/storefront-catalog)
- [Shopify.dev: Checkout MCP](https://shopify.dev/docs/agents/carts-and-checkout/checkout-mcp)
- [WooCommerce developer docs: MCP](https://developer.woocommerce.com/docs/features/mcp/)
- [WooCommerce: agentic commerce](https://woocommerce.com/agentic-commerce/)
- [BigCommerce developer docs: MCP overview](https://docs.bigcommerce.com/developer/api-reference/mcp/overview)
- [Adobe Experience League: Commerce MCP overview](https://experienceleague.adobe.com/en/docs/commerce-learn/ai-and-agentic-commerce/commerce-mcp/commerce-mcp-overview)

Last checked 3 Nov 2026