Setting Up an MCP Server for a Shopify Store
A practical guide to running an MCP server in front of a Shopify store so AI assistants can read products, fetch reviews, and submit checkout intents.
If you run a premium Shopify store and you have started to see ChatGPT and Claude mention competitors when buyers ask product questions, the gap is usually not content. It is access. The model is reading a public page and a static feed; the competitor is exposing live data through an MCP server that the model can call directly. This guide covers what an MCP server is, why a Shopify store needs one, and the smallest version that earns you a seat at the AI shopping table.
How do you set up an MCP server for a Shopify store?
The smallest viable MCP server for a Shopify store has three endpoints: list products with filters, fetch one product by id, and submit a checkout intent that returns a Shopify checkout URL. The server speaks the Model Context Protocol over HTTP, wraps the Shopify Storefront API for the data, and exposes the three actions as MCP tools that an AI assistant can call. Most Shopify-native MCP servers ship in a single weekend by a backend developer comfortable with GraphQL.
The Model Context Protocol is an open standard defined at modelcontextprotocol.io. The specification is JSON-RPC 2.0 and covers tools, resources, prompts, and a sampling protocol that lets agents and servers negotiate behavior. For a Shopify store, the tools surface is what matters most.
What an AI shopping agent actually needs from your store
A buyer asks ChatGPT "find me a leather backpack from Brand X under $400, in stock, ships to Norway." For the model to answer accurately, it needs three things from your store:
- Product list with filters. A way to ask "give me all backpacks under $400 from this brand" and get a structured response.
- Product detail by id. Once the model picks a candidate, it needs the full record: variants, current price, current inventory, materials, dimensions, lead time.
- Checkout intent. Once the buyer confirms, the model needs to hand off to a Shopify checkout URL with the right line items prefilled.
A static product feed handles part of step one and almost none of step two. The MCP server handles all three with live data.
Mapping MCP tools to Shopify Storefront API calls
Shopify exposes a public Storefront API over GraphQL. It is the primary data source for headless and agent setups. A Shopify-native MCP server is a thin layer on top.
list_products tool. Maps to a Storefront API products query with filters for collection, price range, availability, and tag. Return a paginated list of product cards with id, title, price, variants summary, and primary image. Cap the response to 20 items per call so the agent does not get a 100-item dump.
get_product tool. Maps to a Storefront API productByHandle or node query. Return the full product record including variants, inventory, materials, dimensions, and any custom metafields the brand exposes. This is where review counts and ratings should live so the agent has all the signal in one fetch.
create_checkout tool. Maps to a Storefront API cartCreate mutation. The agent passes line items and gets back a checkout URL that the buyer can complete on Shopify's hosted checkout. Include the buyer's accepted region and currency in the request so the URL is correct on first hand-off.
That is the entire viable surface for a v1.
Auth, rate limits, and idempotency
A few practical items most Shopify MCP servers get wrong on the first ship.
Auth. Use Shopify Storefront API tokens for the server-to-Shopify calls and a separate API key on the MCP side for agent-to-server calls. Scope the MCP key to the tools the agent actually needs. A read-only key for ChatGPT product browsing, a write key only when an internal agent needs to create draft orders.
Rate limits. The Shopify Storefront API has a query cost system. A list call with full variant data costs more than a list call with summary data. The MCP server should cache list calls for 30 to 60 seconds and detail calls for 5 to 15 seconds, then invalidate on inventory webhooks. Without caching, an agent that asks 5 follow-up questions burns through the rate limit on a single buyer session.
Idempotency. Checkout creation should accept an idempotency key from the agent and return the same checkout URL if the same key is sent twice. Without this, an agent that retries on a network error creates duplicate carts.
Where the MCP server fits next to a product feed
If you have already submitted a product feed to OpenAI Commerce, you are not done. The feed is for batch retrieval. The MCP server is for live, agent-driven actions.
The two work together:
- Feed. ChatGPT pulls in a daily snapshot of your catalog for the discovery layer. Buyer asks "find me a backpack" and the feed-indexed catalog gets used.
- MCP. Once the model is in a conversation about your brand specifically, it calls your MCP server for live inventory and checkout. Buyer asks "is the small one in stock and can I get it by Friday."
A brand with both signals visible is a brand the model cites and converts. A brand with just one signal is half-visible.
What headless Shopify changes
If your store is already headless on Shopify's headless storefront stack with Hydrogen or a custom frontend, the MCP server is easier to ship because the Storefront API is already wired up and the team is already comfortable with GraphQL. Reuse the queries the storefront uses; just wrap them in MCP tool definitions.
If your store is on a standard Shopify theme with no headless layer, you still ship the MCP server as a standalone service. The theme does not have to change. The MCP server sits next to the storefront and shares the same Storefront API access.
What to skip in v1
Founders who try to ship a v3 MCP server on day one usually do not ship anything for three months. The features to defer:
- Sampling and prompt protocols. Useful later for advanced agent flows. Not needed for product browsing and checkout.
- Bidirectional tool calls. The agent calls your server in v1; the server does not call back. Add later if you build a return-flow agent.
- Custom resources beyond products. Skip exposing customers, orders, and content as MCP resources until you have a specific agent flow that needs them.
- Multi-tenant. If you run one Shopify store, you do not need to support multiple stores from one MCP server. Build for your store first.
Where to start if you have not built one yet
If you have not built an MCP server before, the smallest first step is one tool: list_products. Stand it up against the Storefront API. Test it from Claude Desktop or another MCP client. Make sure the agent can fetch your catalog and answer "what backpacks do you have under $400."
Once that one tool works, add get_product for detail and create_checkout for the hand-off. The whole surface ships in a week of focused work.
If your brand is invisible to ChatGPT Shopping today and you do not know why, fix the page-side signals first. How ChatGPT Shopping actually picks products covers the schema, review, and feed work that has to be in place before the MCP server starts paying off. The ecommerce agent API explainer covers the broader pattern of which actions an AI assistant should be able to take on a brand's behalf.
The buyer is talking to ChatGPT. The page is being read by a machine. The MCP server is what lets the machine get the live answer.