Connect Shopify to Claude: Control Inventory and Fulfillment Ops

If your team uses ChatGPT, check out our guide on connecting Shopify to ChatGPT or explore our broader architectural overview on connecting Shopify to AI Agents.

Giving a Large Language Model (LLM) read and write access to your Shopify store is one of the highest-leverage automation investments an operations team can make. By connecting Shopify to Claude, you can deploy AI agents that instantly triage missing inventory, negotiate wholesale draft orders, process refunds, and audit fulfillment logs.

To make this connection, you need a Model Context Protocol (MCP) server. This server acts as the translation layer, converting Claude's natural language tool calls into structured, authenticated REST API requests against your Shopify store. You can either spend weeks building, hosting, and maintaining this integration infrastructure yourself, or you can use a managed platform like Truto to dynamically generate a secure, production-ready MCP server URL.

This guide breaks down exactly how to use Truto to generate a managed MCP server for Shopify, connect it natively to Claude, and execute complex e-commerce workflows using natural language.

The Engineering Reality of the Shopify API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for Claude to discover tools, the reality of implementing it against Shopify's Admin API is notoriously complex. You are not just integrating a simple REST API - you are navigating a massive, evolving e-commerce data model.

If you decide to build a custom MCP server for Shopify, you own the entire API lifecycle. Here are the specific challenges you will face:

The Inventory Location Disconnect In older e-commerce models, you would simply update a ProductVariant to adjust available stock. Shopify's modern architecture completely decouples this. Inventory is divided into InventoryItem records and InventoryLevel records, which must be attached to specific physical or virtual Location IDs. An LLM operating without strict tool constraints will naturally hallucinate requests to PUT /products/:id to change inventory. A managed MCP server forces the model to use the correct shopify_inventory_levels_adjust endpoints, handling the relational complexity behind the scenes.

Immutable Orders vs Mutable Drafts Shopify enforces strict lifecycle rules on orders. You cannot simply delete or arbitrarily modify a live order that has interacted with a payment gateway. Draft orders, however, are highly flexible and are used for B2B invoicing, wholesale negotiations, and phone orders. If you expose raw endpoints to Claude, the model will often try to apply draft-order mutations to live orders, resulting in silent failures. Truto isolates these into distinct MCP tools (create_a_shopify_draft_order vs shopify_orders_bulk_update), giving the LLM clear boundaries.

Strict API Rate Limits and 429 Handling Shopify utilizes a leaky bucket algorithm for API rate limiting. When you hit the ceiling, Shopify returns an HTTP 429 Too Many Requests error. It is critical to understand how this is managed: Truto does not retry, throttle, or apply backoff on rate limit errors. When Shopify returns a 429, Truto passes that error directly to the caller (your MCP client). However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your AI agent or MCP client is strictly responsible for reading these headers and executing its own retry and backoff logic.

How to Generate a Shopify MCP Server with Truto

Truto dynamically generates MCP tools from an integration's underlying resource definitions and documentation. This means the tools are documentation-driven - ensuring Claude always has accurate JSON Schemas for every Shopify query parameter and request body.

You can spin up a dedicated Shopify MCP server using either the Truto UI or the API.

Method 1: Via the Truto UI

For teams moving fast, the dashboard provides a one-click server generation flow:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Shopify store.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allow read-only methods, filter by specific tags, set an expiration date).
5. Copy the generated MCP server URL. This URL contains a securely hashed token that maps directly to this specific Shopify connection.

Method 2: Via the Truto API

For platform engineers building multi-tenant AI products, you can generate MCP servers programmatically for your users. Make an authenticated POST request to the /mcp endpoint for the specific integrated account.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Shopify Logistics Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["orders", "inventory", "fulfillments"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The Truto API validates the configuration, hashes the token via HMAC for secure distributed storage, and returns a fully initialized server URL. Raw tokens are never stored in plain text.

{
  "id": "mcp_abc123",
  "name": "Shopify Logistics Agent",
  "config": { "methods": ["read", "write"] },
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude requires zero additional code. You simply register the endpoint, and Claude will perform an MCP handshake (initialize), request the tool list (tools/list), and handle execution (tools/call).

Method 1: Via the Claude UI

If you are using a standard Claude workspace or ChatGPT:

1. In your AI client (e.g., Claude), navigate to Settings -> Integrations -> Add MCP Server.
2. Paste the url returned by Truto.
3. Click Add.

Claude will immediately ping the server and populate its context window with the available Shopify tools.

Method 2: Via Manual Configuration File

If you are using Claude Desktop or an AI IDE like Cursor, you can route the connection through the official Server-Sent Events (SSE) transport adapter.

Open your claude_desktop_config.json file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS) and add the following configuration:

{
  "mcpServers": {
    "shopify_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude Desktop. The agent is now natively connected to your Shopify store.

Hero Tools for Shopify Operations

Truto exposes hundreds of endpoints for Shopify. Here are the highest-leverage tools available for your AI agents.

list_all_shopify_orders

Retrieves a paginated list of orders from the store. This tool supports complex filtering by financial status (paid, pending, refunded), fulfillment status, date ranges, and specific order IDs.

Usage Note: By default, Shopify only returns orders from the last 60 days. Accessing older orders requires your app to have explicit "read_all_orders" permissions granted by the merchant.

"Fetch all unfulfilled orders from the past 48 hours that have a financial status of 'paid'. Provide a summary of the line items and the customer emails."

shopify_inventory_levels_adjust

Adjusts the available inventory quantity of a specific inventory item at a single location by a relative delta.

Usage Note: You must provide the inventory_item_id (not the product variant ID) and the location_id. Sending a negative value subtracts from the current stock. Adjusting untracked items will result in an API error.

"Customer reported a damaged unit for inventory item 998877 at the primary warehouse location. Adjust the available stock level by -1."

create_a_shopify_draft_order

Generates a draft order complete with line items, custom pricing, customer details, and shipping lines.

Usage Note: This is the safest way for an LLM to generate wholesale or B2B quotes. The agent can construct the draft, retrieve the generated invoice_url, and draft an email to the customer without impacting live store revenue metrics until the invoice is paid.

"Create a draft order for our B2B client 'Acme Corp'. Add 50 units of the 'Industrial Coffee Maker' variant, apply a 15% manual discount to the total, and get the checkout invoice URL."

shopify_customers_search

Searches the Shopify customer directory using a query string. Matches across email addresses, names, phone numbers, and tags.

Usage Note: Much faster and more reliable than listing all customers and filtering client-side. Returns rich marketing consent data and total historical spend, making it perfect for VIP support triage.

"Search for a customer with the email address 'jane.doe@example.com'. Tell me their lifetime total spent and whether they are opted into email marketing."

create_a_shopify_fulfillment

Creates a fulfillment record for one or many fulfillment orders, attaching tracking numbers and shipping carrier details.

Usage Note: Modern Shopify requires fulfillments to be tied to a fulfillment_order_id rather than a standard order_id.

"Create a fulfillment for fulfillment order ID 12345. Set the tracking number to '1Z9999999999999999' and the tracking company to 'UPS'."

get_single_shopify_product_by_id

Retrieves the complete payload for a specific product, including all variants, images, options, tags, and status details.

Usage Note: Useful for deep-diving into product metadata before making catalog updates or auditing SEO descriptions.

"Get the full product details for product ID 445566. List all available variants and their current prices."

Workflows in Action

Providing an LLM with these tools allows it to execute complex, multi-step business logic autonomously. Here are real-world operational workflows powered by the Shopify MCP server.

1. B2B Wholesale Quote Generation

Persona: Sales Representative

"My client, TechFlow Inc., wants to order 25 units of our Pro Keyboard (SKU: PRO-KB) and 10 units of the Ergonomic Mouse (SKU: ERG-M). Check if we have enough stock at our main warehouse. If we do, create a draft order with a 10% discount, find their contact email, and draft a message with the invoice link."

Agent Execution Steps:

1. Calls list_all_shopify_products to resolve the SKUs to actual Product Variant IDs and Inventory Item IDs.
2. Calls list_all_shopify_inventory_levels using the identified item IDs to confirm stock quantities at the main location.
3. Calls shopify_customers_search to find "TechFlow Inc." and retrieve their customer ID and email.
4. Calls create_a_shopify_draft_order, passing the variants, quantities, a 10% discount payload, and the customer ID.
5. Extracts the invoice_url from the response and outputs the drafted email for the sales rep.

Result: The sales rep receives a ready-to-send email containing the exact Shopify invoice link, with all stock verification and discounting handled automatically.

2. High-Priority Support Triage

Persona: Customer Support Lead

"A customer named Marcus just emailed complaining that his order hasn't arrived. Can you find his most recent order, check its fulfillment status, and tell me where it is?"

sequenceDiagram
    participant Agent as AI Agent
    participant Truto as Truto MCP Server
    participant Shopify as Shopify API

    Agent->>Truto: Call shopify_customers_search<br>query: "Marcus"
    Truto->>Shopify: GET /admin/api/2024-01/customers/search.json
    Shopify-->>Truto: Return customer ID
    Truto-->>Agent: JSON response

    Agent->>Truto: Call shopify_customers_list_orders<br>customer_id: 12345
    Truto->>Shopify: GET /admin/api/2024-01/customers/12345/orders.json
    Shopify-->>Truto: Return recent orders
    Truto-->>Agent: JSON response

    Agent->>Truto: Call list_all_shopify_fulfillments<br>order_id: 98765
    Truto->>Shopify: GET /admin/api/2024-01/orders/98765/fulfillments.json
    Shopify-->>Truto: Return tracking data
    Truto-->>Agent: Tracking URL and status

Agent Execution Steps:

1. Calls shopify_customers_search to map the name to a customer ID.
2. Calls shopify_customers_list_orders to find the most recent unfulfilled or partially fulfilled order.
3. Calls list_all_shopify_fulfillments to extract the exact tracking numbers, carrier names, and latest shipment status.

Result: The support lead is instantly handed the tracking URL, carrier name, and current location of the package without ever logging into the Shopify admin dashboard.

Security and Access Control

Exposing an e-commerce backend to an AI agent requires strict boundary controls. Truto's MCP servers are scoped to individual integrated accounts and offer multiple layers of security to prevent unauthorized data access or catastrophic writes:

• Method Filtering: Restrict an MCP server to read-only operations. By passing methods: ["read"] during server creation, Truto filters out all create, update, and delete tools. The agent physically cannot mutate store data.
• Tag Filtering: Group tools logically. Passing tags: ["orders", "customers"] guarantees the agent cannot access or modify global store settings, products, or webhooks.
• Ephemeral Servers (expires_at): Generate short-lived MCP URLs for temporary agent workflows. Truto handles the backend state cleanup; once the timestamp passes, the server instantly drops all connections and destroys the token.
• Require API Token Authentication: For internal team use, you can set require_api_token_auth: true. This forces the client connecting to the MCP URL to also supply a valid Truto session or API token, ensuring that possessing the URL alone is not enough to execute tools.

Moving Beyond Point-to-Point Scripts

Connecting Claude to Shopify is not just about making API calls - it is about translating complex vendor data models into a format an LLM can reliably execute against.

Building custom MCP servers forces your engineering team to manage schema mappings, rate limits, leaky bucket standardizations, and authentication state. By using Truto to auto-generate managed MCP servers, you eliminate the integration boilerplate. Your agents get immediate, documented access to Shopify's entire resource library, and your engineers can focus on building intelligent operational workflows rather than maintaining point-to-point infrastructure.