Shopify Store MCP Servers

While the official Shopify Dev MCP provides developer documentation and schema introspection, store MCP servers connect directly to your Shopify store's Admin API. They let AI tools perform real operations -- creating products, fetching orders, managing inventory, updating customers -- all through natural language.

Several community-built MCP servers provide store connectivity. This guide covers the most mature and widely used options.

Use Development Stores for Learning

Store MCP servers perform real operations on your Shopify store. A command like "delete all draft products" will actually delete them. Always use a development store when learning and testing. Never connect a production store until you understand exactly what operations are being performed.

Authentication: Access Tokens vs OAuth

Before setting up any store MCP server, you need to understand Shopify's authentication model, which changed significantly in January 2025.

Custom App Access Tokens (Legacy and Existing Apps)

For apps created before January 2025, or for custom apps created through the Shopify admin:

Go to your Shopify admin > Settings > Apps and sales channels
Click Develop apps > Create an app
Configure Admin API scopes (select the permissions you need)
Install the app and copy the Admin API access token

Access token format
shpat_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

OAuth Credentials (New Apps Since January 2025)

Shopify deprecated direct access token creation for new public and custom apps starting January 2025. New apps use OAuth client credentials:

Create your app in the Shopify Partner Dashboard
Note your Client ID and Client Secret
Use the OAuth flow to obtain an access token
The MCP server handles token refresh automatically

Which Method Do You Need?

Development store with custom app: Use access tokens (simpler setup)
New app via Partner Dashboard: Use OAuth credentials
Existing app with stored tokens: Use the existing access token

Most MCP servers support both methods. Check the specific server's documentation for configuration options.

shopify-mcp by GeLi2001

The most comprehensive community MCP server with 70+ tools covering nearly every Admin API operation. This is the recommended choice for full store management.

Repository: github.com/GeLi2001/shopify-mcp

Installation for Claude Code

Install with access token
claude mcp add shopify-store -- npx -- -y shopify-mcp --accessToken shpat_your_token_here --domain your-store.myshopify.com

Install with OAuth credentials
claude mcp add shopify-store -- npx -- -y shopify-mcp --clientId your_client_id --clientSecret your_client_secret --domain your-store.myshopify.com

Configuration for Cursor

.cursor/mcp.json
{
  "mcpServers": {
    "shopify-store": {
      "command": "npx",
      "args": [
        "-y",
        "shopify-mcp",
        "--accessToken", "shpat_your_token_here",
        "--domain", "your-store.myshopify.com"
      ]
    }
  }
}

Available Operations

The server provides tools organized by resource type:

Products (15+ tools)

Tool	Description
`get_products`	List products with filtering and pagination
`get_product`	Get a single product by ID
`create_product`	Create a new product with variants
`update_product`	Update product fields
`delete_product`	Delete a product
`get_product_variants`	List variants for a product
`create_product_variant`	Add a variant to a product
`update_product_variant`	Modify variant details
`get_product_images`	List product images
`upload_product_image`	Add an image to a product

Example: Create a product
> Create a new product called "Organic Cotton T-Shirt" with sizes
  S, M, L, XL. Price the small at $29.99 and add $2 for each
  size up. Set inventory to 50 units per variant at our main location.

Orders (10+ tools)

Tool	Description
`get_orders`	List orders with status filters
`get_order`	Get a single order with line items
`create_fulfillment`	Fulfill an order
`cancel_order`	Cancel an order
`create_draft_order`	Create a draft order
`get_order_risks`	Check order fraud risk

Example: Find unfulfilled orders
> Show me all unfulfilled orders from the last 48 hours with
  their customer email and total value.

Customers (8+ tools)

Tool	Description
`get_customers`	List customers with search
`get_customer`	Get customer details
`create_customer`	Create a new customer
`update_customer`	Update customer info
`get_customer_orders`	List a customer's orders
`search_customers`	Search by email, name, etc.

Collections (6+ tools)

Tool	Description
`get_collections`	List all collections
`get_smart_collections`	List smart (automated) collections
`create_collection`	Create a custom collection
`add_product_to_collection`	Add products to a collection
`get_collection_products`	List products in a collection

Inventory (5+ tools)

Tool	Description
`get_inventory_levels`	Check inventory at locations
`adjust_inventory`	Adjust inventory quantities
`get_locations`	List store locations
`set_inventory_level`	Set absolute inventory level

Discounts (6+ tools)

Tool	Description
`get_price_rules`	List price rules
`create_price_rule`	Create a discount rule
`create_discount_code`	Generate a discount code
`get_discount_codes`	List codes for a price rule

Pagination Patterns

Shopify's API uses cursor-based pagination. The MCP server handles this, but understanding the pattern helps you make effective requests:

Paginated request
> List all products (I have about 500). Fetch them in batches
  of 50 and compile the complete list.

The MCP server will make multiple paginated API calls behind the scenes, following pageInfo.hasNextPage and using the endCursor for subsequent requests.

Avoid Fetching Everything

Even though the MCP server handles pagination, fetching thousands of items consumes time and tokens. Be specific: "List the 20 most recently updated products" is better than "List all products" when you don't need the full catalog.

@ajackus/shopify-mcp-server

An alternative community server with a focus on simplicity and essential operations.

Installation

Install @ajackus server
claude mcp add shopify-ajackus -- npx -- -y @ajackus/shopify-mcp-server --token shpat_your_token --shop your-store.myshopify.com

This server provides a smaller, curated set of tools focused on the most common operations. It's a good choice if you want fewer tools with less complexity.

Python Implementation

For teams that prefer Python, there's a Python-based Shopify MCP server:

Install Python MCP server
pip install shopify-mcp-server

Claude Desktop configuration (Python server)
{
  "mcpServers": {
    "shopify-store": {
      "command": "python",
      "args": ["-m", "shopify_mcp_server"],
      "env": {
        "SHOPIFY_ACCESS_TOKEN": "shpat_your_token_here",
        "SHOPIFY_STORE_DOMAIN": "your-store.myshopify.com"
      }
    }
  }
}

Python vs Node.js MCP Servers

Both provide similar functionality. Choose based on your team's language preference. The Node.js servers (shopify-mcp, @ajackus) tend to be updated more frequently since Shopify's own tooling is Node.js-centric. The Python server is better if you're integrating with Python-based data pipelines.

SSE Transport Configuration

Some MCP servers support running as a persistent HTTP service using Server-Sent Events (SSE), which is useful for shared team access:

Start server with SSE transport
npx shopify-mcp --accessToken shpat_xxx --domain store.myshopify.com --transport sse --port 3100

Then configure Claude Code to connect via SSE:

Claude Code SSE configuration
{
  "mcpServers": {
    "shopify-store": {
      "url": "http://localhost:3100/sse"
    }
  }
}

Benefits of SSE transport:

Multiple developers can share one MCP server instance
Server stays warm (no startup delay per session)
Centralized token management (developers don't need individual tokens)
Can be deployed behind authentication on a team server

Practical Workflows

Workflow 1: Product Catalog Audit

Audit workflow
> Analyze our product catalog:
  1. List all products with no images
  2. Find products with variants that have $0 price
  3. Identify products with no inventory at any location
  4. List products without descriptions

  Compile this into a report with product titles and IDs.

Workflow 2: Order Investigation

Order investigation
> A customer (email: customer@example.com) says they haven't
  received their order. Look up their recent orders, check
  fulfillment status, and summarize what I should tell them.

Workflow 3: Bulk Operations

Bulk update
> Add the tag "summer-2026" to all products in the "Summer
  Collection" collection. Also set a metafield
  custom.seasonal = "summer" on each one.

Workflow 4: Inventory Reconciliation

Inventory check
> Compare inventory levels between our "Main Warehouse" and
  "Retail Store" locations. List any products where the total
  across both locations is under 10 units.

Security Best Practices

Scope Minimization

Create your access token with only the scopes needed for your workflow:

Workflow	Minimum Scopes
Product management	`read_products`, `write_products`
Order viewing	`read_orders`
Full store management	`read_products`, `write_products`, `read_orders`, `write_orders`, `read_customers`, `read_inventory`, `write_inventory`

Never Use Full Admin Access for MCP

Resist the temptation to grant all scopes "just in case." If your MCP workflow only reads orders, only grant read_orders. If the MCP server is compromised or misused, limited scopes limit the damage. This is especially important when using community-built servers.

Token Rotation

Rotate your access tokens periodically:

Create a new custom app with the same scopes
Update the MCP server configuration with the new token
Uninstall the old custom app

Environment Variables

Never hardcode tokens in configuration files that get committed to version control:

Use environment variables
# In your shell profile
export SHOPIFY_MCP_TOKEN=shpat_your_token_here
export SHOPIFY_MCP_DOMAIN=your-store.myshopify.com

# In Claude Code MCP configuration
claude mcp add shopify-store -- npx -- -y shopify-mcp --accessToken $SHOPIFY_MCP_TOKEN --domain $SHOPIFY_MCP_DOMAIN

Troubleshooting

"Unauthorized" Errors

Verify your access token is correct and hasn't been revoked
Check that the token has the required scopes for the operation
Ensure the store domain is correct (use the .myshopify.com domain)

Rate Limiting

If you're seeing rate limit errors during bulk operations:

Rate-limited request
> Retry the operation with a 500ms delay between API calls.
  My store is rate-limited right now.

Most MCP servers handle rate limiting automatically, but very aggressive bulk operations may still hit limits.

Missing Data

If queries return unexpected empty results:

Check that products/orders are in the expected status (active, not draft/archived)
Verify date range filters are in the correct format
Confirm the access token has read_ scopes for the resource type

Next Steps

With store data access configured, you can enhance your workflow further with analytics. Proceed to Analytics MCP to learn about connecting Shopify analytics and reporting tools via MCP.

Authentication: Access Tokens vs OAuth​

Custom App Access Tokens (Legacy and Existing Apps)​

OAuth Credentials (New Apps Since January 2025)​

shopify-mcp by GeLi2001​

Installation for Claude Code​

Configuration for Cursor​

Available Operations​

Products (15+ tools)​

Orders (10+ tools)​

Customers (8+ tools)​

Collections (6+ tools)​

Inventory (5+ tools)​

Discounts (6+ tools)​

Pagination Patterns​

@ajackus/shopify-mcp-server​

Installation​

Python Implementation​

SSE Transport Configuration​

Practical Workflows​

Workflow 1: Product Catalog Audit​

Workflow 2: Order Investigation​

Workflow 3: Bulk Operations​

Workflow 4: Inventory Reconciliation​

Security Best Practices​

Scope Minimization​

Token Rotation​

Environment Variables​

Troubleshooting​

"Unauthorized" Errors​

Rate Limiting​

Missing Data​

Next Steps​