• A Shopify store on any plan (the MCP path doesn't require Plus).
• Node.js 20+ on your machine or deployment target (Vercel functions work too).
• An Anthropic API key — pay-as-you-go, no monthly minimum.
• 20 minutes if you DIY. 5 minutes if you connect through BoostEcom.

In your store admin: Settings → Apps and sales channels → Develop apps → Create app. Name it Claude integration. The default Admin API section is what we'll configure.

Grant scopes by use case. Start narrow:

| Use case | Scopes | |---|---| | Catalog audit (read-only) | read_products, read_inventory, read_content | | Order analysis | read_orders, read_customers, read_analytics | | Copy rewrite | + write_products, write_content | | Promotions | + write_discounts |

Install the app. Save the Admin API access token somewhere safe — Shopify shows it once.

We ship a hardened, production-ready server with per-tool scope checks baked in. Install in three commands:

npx @boostecom/mcp-shopify init
# follow the prompts: paste your shop domain + Admin API token
npx @boostecom/mcp-shopify start

The server exposes 23 typed tools covering products, collections, themes, menus, metafields, redirects, orders, customers, locations, inventory, analytics. Every tool ships its own scope check — if Claude asks for update_metafield and the server only has read_* scopes, the call is refused without ever hitting Shopify.

→ The full listing lives at /marketplace/mcp/shopify-admin.

Why we publish the server instead of code samples

Three reasons:

1. Versioning — Shopify ships API updates every quarter. The server is the only thing you need to bump; your tool definitions stay stable.
2. Audit log — every tool invocation is logged with the calling model, the timestamp, the input, the output. Replay-friendly.
3. Scope drift detection — the server compares the granted scopes against the tools the model is trying to use, and surfaces the delta. No more "why is the audit silently skipping orders?".

Anthropic's SDK accepts MCP transports natively:

import Anthropic from "@anthropic-ai/sdk"
import { MCPClient } from "@anthropic-ai/sdk/mcp"

const claude = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
const mcp = await MCPClient.connect({
  command: "npx",
  args: ["@boostecom/mcp-shopify", "start"],
  env: { SHOPIFY_SHOP: "yourshop.myshopify.com", SHOPIFY_TOKEN: "shpat_…" },
})

const response = await claude.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 4096,
  mcp_servers: [mcp],
  messages: [
    {
      role: "user",
      content: "Audit my product catalog. Flag PDPs missing schema, weak titles, and broken images. Return JSON.",
    },
  ],
})

The model auto-discovers the tools, calls them in a chain, and returns structured output. No manual tool-loop code.

Most production workloads share the same shape:

1. Discovery — model lists products, gets a sample of N.
2. Scoring — model evaluates each one against criteria (schema, title length, image count, price tier).
3. Prioritisation — model returns the top-K with rationale.
4. (Optional) Action — model writes the fix back via write_* scopes, gated behind human approval.

The BoostEcom platform ships this loop as a reusable skill. The DIY version is ~150 lines of orchestration code with retry logic, error boundaries, and rate-limit handling for both Anthropic and Shopify.

Every Claude × Shopify deployment we've seen fail had the same root cause: too many scopes, too early.

Phase 1 — observe (read-only): live with the audit in production for one week. Watch what Claude reads, what it ignores, what it tries to do that it can't. Read-only is the longest phase and the most informative.

Phase 2 — author (write_products, write_content): let Claude rewrite copy ON A STAGING THEME. Compare the rewrites to your existing copy, accept what you trust, reject what you don't. Two weeks.

Phase 3 — operate (selective write_*): grant operations on specific surfaces (discounts, inventory). Always behind human approval for destructive actions.

Never grant: write_payment_*, write_users, write_files. A hallucination here is unrecoverable.

The MCP server alone gets you 60% of the way. The remaining 40%:

• Multi-store routing — one MCP per store doesn't scale at 10+ stores. BoostEcom keeps a per-org credential pool with isolated audit logs.
• Session memory — Claude needs context that survives across conversations. We persist conversation state, store knowledge base, workflow runs.
• Voice + WhatsApp — operators don't always want to type. Hume EVI integration for voice, WhatsApp connector for thumb-driven ops.
• Marketplace skills — pre-built audit / rewrite / experiment workflows. One click from the marketplace, no prompt engineering.
• Specialist agents — beyond Claude, BoostEcom routes specialist models for ops, finance, support, growth. @Atlas orchestrates.

→ See the full feature list at /features/ai-copilot.

Does MCP require Shopify Plus?

No. MCP is a transport protocol on top of any Shopify Admin API access. Custom Apps work on every plan including Basic.

Can I run the MCP server in a serverless environment?

Yes — the server is stateless. Vercel Functions, AWS Lambda, Cloudflare Workers all work. For long-running audits we recommend a small VM (2 vCPU, 4 GB RAM is plenty).

How does Claude know which tools the server exposes?

MCP advertises tool schemas at handshake. Claude downloads the schema list once per session, then calls tools by name with typed arguments. You don't pre-register anything in the Claude SDK.

What about rate limits?

Shopify's GraphQL Admin API uses a calculated point cost (1000-point bucket, refilled at 50 points/sec). The BoostEcom MCP server tracks points + auto-throttles. DIY: implement leaky-bucket throttling around every fetch.

Can I bring my own Anthropic API key (BYOK)?

Yes — Account → Tokens → BYOK. Claude calls go to your account, not through BoostEcom's billing.