Skip to main content
Glama

Shopify MCP

License: MIT MCP Shopify Admin API

A single MCP server exposing the full Shopify Admin GraphQL API read surface (version 2026-04) through 6 universal tools. Read-only is enforced at the query-parser level: mutations are rejected before they ever reach Shopify, not merely discouraged. Multi-store by design: one server instance can serve many shops.

Built and maintained by Scalably. Runs on the Model Context Protocol. License: MIT.

Why read-only at the parser level? Giving an AI agent write access to a live store is how you end up with a deleted product or a wrong-priced variant. This server enforces read-only by parsing every query and rejecting mutations before they leave the process, not by trusting the model to behave, and not by relying on Shopify-side scopes alone. It's the safety boundary an agent in production actually needs. (more on the pattern)

Install

Claude Code:

claude mcp add shopify -e SHOPIFY_DOMAIN=my-store.myshopify.com -e SHOPIFY_ACCESS_TOKEN=shpat_... -- uvx scalably-shopify-mcp

Codex:

codex mcp add shopify --env SHOPIFY_DOMAIN=my-store.myshopify.com --env SHOPIFY_ACCESS_TOKEN=shpat_... -- uvx scalably-shopify-mcp

Claude Desktop: download shopify-mcp.mcpb from the latest GitHub release and open it.

Related MCP server: shopify-mcp

Setup

Single store (simplest)

  • SHOPIFY_DOMAIN or SHOPIFY_SHOP_DOMAIN - <shop>.myshopify.com

  • Auth path A: SHOPIFY_ACCESS_TOKEN (legacy shpat_)

  • Auth path B: SHOPIFY_CLIENT_ID + SHOPIFY_CLIENT_SECRET (Dev Dashboard custom app, client-credentials OAuth, 24h tokens auto-refreshed)

The single store registers under alias default; callers can omit the shop argument on tool calls.

Multi-store (agency setups)

Set SHOPIFY_STORES to a JSON object mapping alias to store config:

{
  "main":   {"domain": "my-store.myshopify.com",        "client_id": "...", "client_secret": "..."},
  "outlet": {"domain": "my-store-outlet.myshopify.com", "client_id": "...", "client_secret": "..."},
  "legacy": {"domain": "legacy-store.myshopify.com",    "access_token": "shpat_..."}
}
  • Each store can use either client_id + client_secret (Dev Dashboard OAuth) or access_token (legacy shpat_).

  • Aliases: [a-z0-9][a-z0-9_-]{0,63}, lowercase-normalized on load.

  • Token cache is per-store-domain; one throttled store doesn't block others.

Scopes needed (read-only)

Minimum viable: read_products read_orders read_customers.

Recommended baseline: read_products read_orders read_customers read_inventory read_locations read_fulfillments read_discounts read_content read_themes read_files read_markets read_metaobjects read_metaobject_definitions read_reports read_translations read_locales read_shipping.

Add read_all_orders for order history older than 60 days. Enable Protected customer data access in Dev Dashboard, Configuration, if the agent needs customer PII.

Tools (6)

Tool

What it does

shopify_list_stores

List all Shopify stores configured for this agent. Call first.

shopify_graphql_query

Arbitrary read-only GraphQL. Mutations rejected by the parser.

shopify_graphql_introspect

Schema introspection, full catalog or a single type.

shopify_bulk_query

Launch an async bulk export (JSONL).

shopify_bulk_poll

Poll a bulk operation status and download URL.

shopify_shopifyql

ShopifyQL analytics (SQL-like; requires read_reports).

Every non-list tool takes an optional shop argument (alias or domain). Required when more than one store is configured; auto-selected when exactly one.

Coverage

The full Admin GraphQL API read surface: any object, field, or connection accessible with the token's scopes is reachable via shopify_graphql_query. Anything large-scale (more than 10k records) should use shopify_bulk_query. Analytics goes through shopify_shopifyql.

Configuration

Variable

Required

Purpose

SHOPIFY_DOMAIN, SHOPIFY_SHOP_DOMAIN

one of these or SHOPIFY_STORES

Single-store admin domain, <shop>.myshopify.com

SHOPIFY_ACCESS_TOKEN

see above

Legacy shpat_ access token (single-store auth path B)

SHOPIFY_CLIENT_ID, SHOPIFY_CLIENT_SECRET

see above

Dev Dashboard custom-app credentials (single-store auth path A)

SHOPIFY_STORES

no

JSON object mapping alias to store config; takes precedence over the single-store variables above

SHOPIFY_STORE_<ALIAS>_DOMAIN, _CLIENT_ID, _CLIENT_SECRET, _ACCESS_TOKEN

no

Prefix-key alternative to SHOPIFY_STORES for multi-store setups; one set of keys per store alias

SHOPIFY_REQUEST_TIMEOUT_SECONDS

no

HTTP request timeout in seconds (default 60)

SHOPIFY_LOG_LEVEL

no

INFO (default) or DEBUG

Read-only enforcement

Every query is parsed with graphql-core before transmission. The parser rejects:

  • subscription operations (not supported by the Admin API anyway)

  • Any top-level mutation except bulkOperationCancel (cancels an in-flight bulk job, no shop-data write)

  • Malformed GraphQL (syntax errors)

  • Queries over 100KB

bulkOperationRunQuery is not in the generic parser allowlist. Legitimate bulk exports go through the dedicated shopify_bulk_query tool, which validates the inner query with the same read-only check before wrapping it in the bulk mutation. Single source of truth, no reliance on Shopify-side validation.

Rate limiting

Per-store cost-based leaky bucket (Shopify's model). Each response includes extensions.cost.throttleStatus. On THROTTLED errors, the server sleeps ceil((requestedQueryCost - currentlyAvailable) / restoreRate) seconds (minimum 1s) and retries up to 3 times before surfacing the error. Buckets are independent per store: a throttle on one store doesn't affect another.

Reply shape

Tool replies mirror the underlying call rather than a uniform envelope. shopify_list_stores returns a JSON array of {alias, domain, name, currency, auth_mode}; every GraphQL-backed tool (shopify_graphql_query, shopify_graphql_introspect, shopify_bulk_query, shopify_bulk_poll, shopify_shopifyql) returns the raw Shopify Admin API response, {"data": ..., "errors": ..., "extensions": ...}, unwrapped. Tool-level failures (bad input, redacted transport errors) raise a plain error.

Limits

100KB query size ceiling. Bulk exports: exactly one top-level connection per query, max 5 total connections, max depth 2, every nested connection node selects id without an alias; one bulk operation at a time per shop on API versions through 2025-10, up to 5 on 2026-01 and later. API version defaults to 2026-04; override per call with api_version="YYYY-MM".

Verify

Each release lists the package version, the .mcpb sha256 and the production commit it was derived from in CHANGELOG.md. CI runs the tests and a clean install of the built wheel on every push.

Privacy Policy

This connector runs locally, on your own machine, under your own Shopify credentials. It is a thin read-only bridge between your MCP client and Shopify's Admin API.

  • Data collection: The connector collects no personal data and contains no telemetry, analytics, or external reporting. It does not phone home.

  • Data usage: Shopify store data you query is returned to your local MCP client to fulfill your request, and is not used for any other purpose.

  • Data storage: The connector stores nothing persistently. Access tokens are held in memory only for the life of the process and are never written to disk. The only network destination is Shopify's own API (*.myshopify.com), enforced by a domain allowlist.

  • Third-party sharing: None. Data flows only between your machine and Shopify. No third party, including the connector's author, ever receives your data or credentials.

  • Retention: No data is retained by the connector after the process exits.

  • Secret handling: Access tokens, client secrets, and all Shopify token prefixes are redacted from logs and error messages.

  • Contact: hello@scalably.io

The canonical hosted version of this policy: https://scalably.io/connector-privacy.html

License

MIT. Copyright Scalably.

Learn more

We write about building production MCP servers and AI agents at scalably.io/blog:

References

Available Tools

6 tools
shopify_bulk_pollA
Read-onlyIdempotent

Poll a bulk operation's status by ID.

Statuses: CREATED, RUNNING, COMPLETED, CANCELED, EXPIRED, FAILED. On COMPLETED, the url field is a pre-signed JSONL download (valid 7 days). On FAILED, partialDataUrl may hold partial results; errorCode explains why.

Args: operation_id: Global ID of the bulk operation (format: gid://shopify/BulkOperation/<numeric-id>). shop: Store alias or domain the bulk op was launched on. Required when multiple stores are configured. api_version: Override API version (default "2026-04").

Inputs: operation_id (required), shop, api_version. Returns: result

shopify_bulk_queryA
Read-only

Launch an async bulk export of a read-only GraphQL query.

Use for exporting datasets too large for paginated queries (>10k records, or anything you'd otherwise paginate hundreds of times). Shopify runs the query in the background and produces a JSONL file with all results.

Restrictions (enforced by Shopify):

  • Exactly one top-level connection per query.

  • Max 5 total connections, max depth 2.

  • Every nested connection node must select id without an alias.

  • API ≤ 2025-10: one bulk op at a time per shop. API ≥ 2026-01: up to 5.

Returns the BulkOperation ID - poll with shopify_bulk_poll.

Args: query: Read-only GraphQL document with a single root connection. shop: Store alias or domain. Required when multiple stores are configured. api_version: Override API version (default "2026-04").

Inputs: query (required), shop, api_version. Returns: result

shopify_graphql_introspectA
Read-only

Introspect a Shopify store's Admin GraphQL schema.

Pass type_name to fetch a single type's fields (cheap, ~50 cost points). Omit it for the full schema type catalog (expensive, ~800 cost points - use sparingly).

Args: type_name: GraphQL type name (e.g. "Order", "Product", "Customer"). Must match [A-Za-z_][A-Za-z0-9_]*. Omit for full schema. shop: Store alias or domain (see shopify_list_stores). Required when multiple stores are configured. api_version: Override API version (default "2026-04").

Inputs: shop, type_name, api_version. Returns: result

shopify_graphql_queryA
Read-only

Execute a read-only GraphQL query against a Shopify store's Admin API.

Universal entry point for reading any data the token's scopes permit: products, variants, orders, customers, inventory, fulfillments, discounts, locations, markets, metafields, metaobjects, segments, shop settings, etc.

Full GraphQL reference: https://shopify.dev/docs/api/admin-graphql

Write mutations are rejected by design. The query string is parsed and validated as read-only before transmission.

Idiomatic patterns:

  • Pagination: first: <=250, after: <cursor>, read pageInfo { hasNextPage endCursor }.

  • Search: pass a Shopify search string to the query: arg on connections, e.g. orders(first: 100, query: "created_at:>=2026-04-01 financial_status:paid").

  • Money: totalPriceSet { shopMoney { amount currencyCode } }.

  • For datasets >10k records, use shopify_bulk_query instead.

Args: query: GraphQL document. Must be a query or a fragment. Subscription and mutation operations are rejected - with one narrow exception, bulkOperationCancel. For bulk exports, use shopify_bulk_query. variables: Optional variables dict passed as GraphQL variables. shop: Store alias (from shopify_list_stores) or domain. Required when multiple stores are configured; optional (auto-selected) when there's only one store. api_version: Override API version (default "2026-04"). Format "YYYY-MM".

Inputs: query (required), shop, variables, api_version. Returns: result

shopify_list_storesA
Read-only

List all Shopify stores configured for this agent.

Returns a JSON array of {alias, domain, name, currency, auth_mode}. The name field is the merchant's own shop name from Shopify (fetched once per process, cached). Use this list to match user intent - e.g., a user saying "check the outlet" maps to the store whose name or domain contains "outlet".

If only one store is configured, shop can be omitted on tool calls.

Args: refresh: If True, bypass the shop-name cache and re-fetch from Shopify. Use after a merchant renames a shop in the Shopify admin.

Inputs: refresh. Returns: result

shopify_shopifyqlA
Read-only

Run a ShopifyQL analytics query against a Shopify store.

ShopifyQL is Shopify's SQL-like reporting language. Requires read_reports scope. Consumes the same cost bucket as GraphQL.

Syntax: FROM SHOW [, ...] [BY ] [GROUP BY ] [WHERE ] [SINCE -Nd UNTIL today] [ORDER BY [ASC|DESC]] [LIMIT N]

Datasets: sales, orders, products, customers, inventory, sessions. Time tokens: -Nd / -Nw / -Nm / -Nq / -Ny, or named (today, yesterday, this_week, last_week, this_month, last_month, last_year).

Examples:

  • FROM sales SHOW total_sales GROUP BY day SINCE -7d UNTIL today ORDER BY day ASC

  • FROM sales SHOW total_sales BY product_title ORDER BY total_sales DESC LIMIT 10 SINCE -30d

  • FROM sales SHOW returning_customer_rate GROUP BY month SINCE -6m

  • FROM sales SHOW net_sales SINCE -1q UNTIL today

  • FROM sessions SHOW sessions, conversion_rate GROUP BY referrer_source SINCE -14d

Returns tableData.columns, tableData.rows, and parseErrors. When parsing fails, tableData is null and parseErrors contains a list of human-readable error strings (e.g. "Column 'total_sale' not found").

Args: query: ShopifyQL query string. shop: Store alias or domain. Required when multiple stores are configured. api_version: Override API version (default "2026-04").

Inputs: query (required), shop, api_version. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.7/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a distinct role: store discovery, direct GraphQL reads, schema introspection, async bulk exports, bulk status polling, and ShopifyQL analytics. The potential overlap between graphql_query and bulk_query is clearly resolved by scale and execution model guidance.

    Naming Consistency4/5

    All tools share a consistent shopify_ prefix and snake_case style, with clear verb/noun combinations like list_stores, bulk_query, and bulk_poll. The name shopify_shopifyql is slightly redundant and breaks the verb-led pattern, but the overall convention remains predictable.

    Tool Count5/5

    Six tools is well-scoped for a Shopify read/analytics MCP server. Each tool addresses a distinct need without redundancy, and the count is comfortably within the ideal range.

    Completeness5/5

    The universal GraphQL query tool provides read access to virtually any Shopify resource, while bulk_query and bulk_poll cover large exports and ShopifyQL covers analytics. Store discovery and schema introspection complete the read-only surface, leaving no significant operational dead ends.

    Maintenance

    ActivityStale
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Production-grade MCP server for the Shopify Admin GraphQL API, exposing typed tools for AI agents to manage products, orders, customers, and more.
      41 npm
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server providing six scoped tools for Shopify's Admin API, enabling natural-language querying of chargebacks, orders, refunds, customers, and revenue.
      -
    • A
      license
      A
      quality
      D
      maintenance
      A read-only MCP server that lets AI assistants answer Shopify store operations questions via tools like get_shop, list_products, get_product, and list_orders.
      4
      MIT
    • F
      license
      A
      quality
      D
      maintenance
      Security-focused MCP server for Shopify Admin GraphQL with read-only queries by default and mutations requiring preview and one-time confirmation. It manages short-lived tokens internally and enforces strict scope and approval controls.
      4
      10 npm
      -