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.
Table of Contents
- 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 titlelimit(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 fromlimit(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 returnnext(optional string): Next page cursor
- Returns: Customer data in JSON format
tag-customer
- Add tags to a customer
- Inputs:
customerId(string): Customer ID to tagtags(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 returnafter(optional string): Next page cursorquery(optional string): Filter orders using query syntaxsortKey(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 discountcode(string): Discount code that customers will entervalueType(enum): Type of discount ('percentage' or 'fixed_amount')value(number): Discount value (percentage as decimal or fixed amount)startsAt(string): Start date in ISO formatendsAt(optional string): Optional end date in ISO formatappliesOncePerCustomer(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 quantityemail(string): Customer emailshippingAddress(object): Shipping address detailsnote(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 completevariantId(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 returnname(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 URLtopic(enum): Webhook topic to subscribe towebhookId(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:```bash
git clone https://github.com/your-username/shopify-mcp-server.git
2. Navigate to the project directory:```bash
cd shopify-mcp-server
- Install dependencies:```bash
npm install
4. Create a `.env` file with your Shopify credentials:```
SHOPIFY_ACCESS_TOKEN=your_access_token
MYSHOPIFY_DOMAIN=your-store.myshopify.com
- Build the project:```bash
npm run build
6. Run the server:```bash
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.
Usage with Claude Desktop
Add to your claude_desktop_config.json:```json
{
"mcpServers": {
"shopify": {
"command": "npx",
"args": ["-y", "shopify-mcp-server"],
"env": {
"SHOPIFY_ACCESS_TOKEN": "<YOUR_ACCESS_TOKEN>",
"MYSHOPIFY_DOMAIN": "<YOUR_SHOP>.myshopify.com"
}
}
}
}
## Development
1. Clone the repository
2. Install dependencies:```bash
npm install
- Create a
.envfile:```
SHOPIFY_ACCESS_TOKEN=your_access_token
MYSHOPIFY_DOMAIN=your-store.myshopify.com
4. Build the project:```bash
npm run build
- Run tests:```bash
npm test
### Testing
The project uses Jest for unit testing. Tests are organized by module structure:
- `src/__tests__/utils/` - Tests for utility functions
- `src/__tests__/tools/` - Tests for tool modules
- `src/__tests__/ShopifyClient.test.ts` - Tests for the Shopify client
To run tests:```bash
npm test
To run tests with coverage report:bash
npm test -- --coverage
Tests use mocks to avoid making real API calls to Shopify, ensuring they run quickly and reliably without requiring actual credentials.
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
- MCP GitHub Discussions
- Report Issues
Built with ❤️ using the Model Context Protocol
Thanks Website (https://rezajafar.com/) for starting the project
