Shopify ships you 60% of the way — JSON-LD on most themes, structured products.json, public cart API. The remaining 40% is variant-aware tool exposure, add-to-cart actions agents can call, inventory-state awareness, and shopper-side MCP that scales across all 4M+ Shopify stores. Most of it requires zero code changes to your theme.
Free wmcp.sh adapter works on every public Shopify store. Or have us audit yours for $499.
Shopify ships JSON-LD Product schema on most themes by default — that's the floor. The remaining work is variants, cart actions, and bridging Shopify's owner-side dev-mcp with the shopper-side stack agents like Claude / OpenAI / Cursor actually use when buying.
Most Shopify themes render variants as a JS-driven dropdown. JSON-LD Product schema lists the parent product, but the actual sellable SKUs (size 10 in red, size 11 in blue) are buried in a JS array agents can't reliably parse.
→ Agent says: "I want Wool Runners size 10." Result: clicks add-to-cart on the default variant. Wrong SKU.
Fix: wmcp.sh's Shopify adapter pulls /products/<handle>.json which always returns the full variants array — every (id, title, price, available, options) tuple. Each variant becomes a callable tool the agent picks deterministically.
Shopify's public storefront has /cart/add.js but no MCP wrapper. Agents have to either drive a browser session (slow, fragile) or you don't get the purchase.
→ Agent reads price + availability but can't act.
Fix: wmcp.sh exposes add_to_cart as an actionable tool for every Shopify store automatically. The agent calls it with {variant_id, quantity} and gets back the updated cart token, no browser required.
When a product is back in stock or a variant sells out, there's no webhook agents can subscribe to. Agents have to re-query, get stale data, or surface "in stock" to users when it isn't.
→ Agent recommends a product that just sold out 30 seconds ago. Trust degraded.
Fix: wmcp.sh caches with a short TTL (60s) for live queries and listens to /products.json?updated_at_min=… for backfill. For high-volume stores, we can wire a Shopify webhook on the store's side that pushes invalidations directly into our cache.
Shopify Markets serves different prices, currencies, and product availability to different geos. Agents fetching server-side see the default locale, not the shopper's intent.
→ A UK shopper's agent gets USD prices because the request originated from a US-region serverless edge.
Fix: Pass locale + country hints in the agent's tool call. wmcp.sh forwards them as Shopify Markets headers so the response reflects the shopper's actual market.
Shopify shipped dev-mcp in 2026 — but it's for store operators managing their OWN store. The shopper agent calling add_to_cart across many stores has no first-party MCP from Shopify and isn't on their roadmap.
→ Every store needs its own integration, none of which scale.
Fix: wmcp.sh is the shopper-side MCP for the entire Shopify ecosystem. One URL: https://wmcp.sh/api/v1/tools?url=<your-product-page>. Works on 4M+ Shopify stores without store-by-store integration.
Most Shopify stores need zero code changes. wmcp.sh works on top of what your theme already outputs.
curl 'https://wmcp.sh/api/v1/tools?url=https://YOUR-STORE.com/products/SOME-HANDLE'. You should see a tools array with get_price, get_availability, add_to_cart, and one tool per variant.application/ld+json with "@type": "Product" is present. (Most themes ship this — Dawn, Sense, Refresh, Crave all do.)/products/<handle>.json returns 200 (not blocked by your Plus Cloudflare rules). If 403, allowlist Claude-User + ChatGPT-User at your WAF.Drop any Shopify product URL into wmcp.sh and you get back agent-callable tools. Here's a working example with Allbirds:
# Get tools for a Shopify product page
curl 'https://wmcp.sh/api/v1/tools?url=https://www.allbirds.com/products/mens-wool-runners'
# Response — agent sees:
{
"adapter": "shopify",
"product": { "title": "Men's Wool Runners", "vendor": "Allbirds" },
"variants": [
{ "id": "39427184461330", "title": "US 10 / Natural Grey", "available": true },
// ... +24 more variants
],
"tools": [
{ "name": "get_price", "result": "$110.00" },
{ "name": "get_availability", "result": "in_stock" },
{ "name": "add_to_cart",
"action": { "kind": "shopify_add_to_cart" },
"description": "Add this product (default variant) to the cart." },
// One add_to_cart_variant_X tool per variant
]
}Most Shopify stores need zero code changes. Point any agent at your store's products via wmcp.sh, free.
We audit your store, ship JSON-LD enhancements, configure WAF allowlists, build custom adapters for your apps, monitor agent traffic.
Product schema on most themes by default — that's the foundation. Three pieces are still missing: WebMCP action markup on cart/checkout buttons, variant-aware tool exposure (agents pick size/color), inventory-real-time tools. Plus Shopify's official MCP server (dev-mcp) is OWNER-side. wmcp.sh fills the shopper-side gap by reading your products.json + variants and exposing add-to-cart actions agents can call./products.json which every store exposes regardless of plan. Custom themes only break things if they disable products.json (rare). Headless Shopify (Hydrogen, custom React) is fully supported via theme-agnostic endpoints./cart/add.js. Final checkout: requires agent to drive a browser session (Computer Use, Browser Use) because Shopify Checkout is JS-heavy. We're shipping a 'checkout assist' tier that returns a pre-filled checkout URL the agent can hand to the human.Claude-User, ChatGPT-User, GoogleOther in your Plus Cloudflare config. Or use wmcp.sh extension-mode which scrapes from a logged-in browser context.The wmcp.sh Shopify integration page covers everything the adapter does (products, variants, cart actions, search), with example curls + Python + cURL ready to paste:
Full adapter docs: works on every public Shopify storefront, variant-aware, add-to-cart actionable. Example code in Python + TypeScript + cURL.
If your store has a custom app shipping its own OpenAPI spec (B2B, headless), the OpenAPI adapter chains in on top of the Shopify base adapter.