Shopify MCP Server

MCP Server for Shopify API, enabling interaction with store data through GraphQL API. This server provides tools for managing products, customers, orders, and more.

Features
Tools
Getting Started
Use Cases
Testimonials
Contributors
Setup
Development
Dependencies
Contributing
License
Community

Features

Product Management: Search and retrieve product information
Customer Management: Load customer data and manage customer tags
Order Management: Advanced order querying and filtering
GraphQL Integration: Direct integration with Shopify's GraphQL Admin API
Comprehensive Error Handling: Clear error messages for API and authentication issues

Tools

get-products
- Get all products or search by title
- Inputs:
  - searchTitle (optional string): Filter products by title
  - limit (number): Maximum number of products to return
- Returns: Formatted product details including title, description, handle, and variants
get-products-by-collection
- Get products from a specific collection
- Inputs:
  - collectionId (string): ID of the collection to get products from
  - limit (optional number, default: 10): Maximum number of products to return
```
        * Returns: Formatted product details from the specified collection
```
get-products-by-ids
- Get products by their IDs
- Inputs:
  - productIds (array of strings): Array of product IDs to retrieve
- Returns: Formatted product details for the specified products
get-variants-by-ids
- Get product variants by their IDs
- Inputs:
  - variantIds (array of strings): Array of variant IDs to retrieve
- Returns: Detailed variant information including product details
get-customers
- Get shopify customers with pagination support
- Inputs:
  - limit (optional number): Maximum number of customers to return
  - next (optional string): Next page cursor
- Returns: Customer data in JSON format
tag-customer
- Add tags to a customer
- Inputs:
  - customerId (string): Customer ID to tag
  - tags (array of strings): Tags to add to the customer
- Returns: Success or failure message
get-orders
- Get orders with advanced filtering and sorting
- Inputs:
  - first (optional number): Limit of orders to return
  - after (optional string): Next page cursor
  - query (optional string): Filter orders using query syntax
  - sortKey (optional enum): Field to sort by ('PROCESSED_AT', 'TOTAL_PRICE', 'ID', 'CREATED_AT', 'UPDATED_AT', 'ORDER_NUMBER')
  - reverse (optional boolean): Reverse sort order
- Returns: Formatted order details
get-order
- Get a single order by ID
- Inputs:
  - orderId (string): ID of the order to retrieve
- Returns: Detailed order information
create-discount
- Create a basic discount code
- Inputs:
  - title (string): Title of the discount
  - code (string): Discount code that customers will enter
  - valueType (enum): Type of discount ('percentage' or 'fixed_amount')
  - value (number): Discount value (percentage as decimal or fixed amount)
  - startsAt (string): Start date in ISO format
```
          * `endsAt` (optional string): Optional end date in ISO format
```
  - appliesOncePerCustomer (boolean): Whether discount can be used only once per customer
- Returns: Created discount details
create-draft-order
- Create a draft order
- Inputs:
  - lineItems (array): Array of items with variantId and quantity
  - email (string): Customer email
  - shippingAddress (object): Shipping address details
  - note (optional string): Optional note for the order
- Returns: Created draft order details
complete-draft-order
- Complete a draft order
- Inputs:
  - draftOrderId (string): ID of the draft order to complete
  - variantId (string): ID of the variant in the draft order
- Returns: Completed order details
get-collections
- Get all collections
- Inputs:
  - limit (optional number, default: 10): Maximum number of collections to return
  - name (optional string): Filter collections by name
- Returns: Collection details
get-shop
- Get shop details
- Inputs: None
- Returns: Basic shop information
get-shop-details
- Get extended shop details including shipping countries
- Inputs: None
- Returns: Extended shop information including shipping countries
manage-webhook
- Subscribe, find, or unsubscribe webhooks
- Inputs:
  - action (enum): Action to perform ('subscribe', 'find', 'unsubscribe')
  - callbackUrl (string): Webhook callback URL
  - topic (enum): Webhook topic to subscribe to
  - webhookId (optional string): Webhook ID (required for unsubscribe)
- Returns: Webhook details or success message

Getting Started

To get started with the Shopify MCP Server, follow these steps:

Clone the repository:

git clone https://github.com/your-username/shopify-mcp-server.git

Navigate to the project directory:

cd shopify-mcp-server

Install dependencies:


            
        
            
                npm install

Create a .env file with your Shopify credentials:

SHOPIFY_ACCESS_TOKEN=your_access_token
MYSHOPIFY_DOMAIN=your-store.myshopify.com

Build the project:

npm run build

Run the server:

npm start

Use Cases

Example 1: Managing Products

With the Shopify MCP Server, you can easily manage your products. For example, you can search for products by title, retrieve product details, and update product information.

Example 2: Handling Orders

The server provides advanced order querying and filtering capabilities. You can retrieve orders based on various criteria, such as order status, date range, and customer information.

Testimonials

"The Shopify MCP Server has greatly simplified our product management process. It's a powerful tool that saves us a lot of time." - John Doe, Store Owner

"We love the advanced order filtering options. It makes it so much easier to find specific orders and manage our store efficiently." - Jane Smith, E-commerce Manager

Setup

Shopify Access Token

To use this MCP server, you'll need to create a custom app in your Shopify store:

From your Shopify admin, go to Settings > Apps and sales channels
Click Develop apps (you may need to enable developer preview first)
Click Create an app
Set a name for your app (e.g., "Shopify MCP Server")
Click Configure Admin API scopes
Select the following scopes:
- read_products, write_products
- read_customers, write_customers
- read_orders, write_orders
Click Save
Click Install app
Click Install to give the app access to your store data
After installation, you'll see your Admin API access token
Copy this token - you'll need it for configuration

Note: Store your access token securely. It provides access to your store data and should never be shared or committed to version control.

            More details on how to create a Shopify app can be found [here](https://help.shopify.com/en/manual/apps/app-types/custom-apps).

Usage with Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "shopify": {
      "command": "npx",
      "args": ["-y", "shopify-mcp-server"],
      "env": {
        "SHOPIFY_ACCESS_TOKEN": "",
        "MYSHOPIFY_DOMAIN": ".myshopify.com"
      }
    }
  }
}

Development

Clone the repository
Install dependencies:

npm install

Create a .env file:

SHOPIFY_ACCESS_TOKEN=your_access_token
MYSHOPIFY_DOMAIN=your-store.myshopify.com

Build the project:

npm run build

Run tests:

npm test

Dependencies

@modelcontextprotocol/sdk - MCP protocol implementation
graphql-request - GraphQL client for Shopify API
zod - Runtime type validation

Contributing

Contributions are welcome! Please read our Contributing Guidelines first.

License

MIT

Community

Built with ❤️ using the Model Context Protocol

For more information, visit my website.

shopify-mcp-server-main

Language:

Stars:

Forks: