Shopify MCP Server

Add one or more products to a collection in the connected Shopify store. Use this when the user wants to organize products into a collection. Find the collection's GID with search_collections first.

Create a new collection in the connected Shopify store and publish it to the Online Store. Use this when the user wants to organize products into a new group. COLLECTION TYPES: - Manual collection: pass `productIds` to add specific products. - Smart collection: pass `ruleSet` with conditions to auto-populate products. - `productIds` and `ruleSet` are mutually exclusive — provide one or neither. SMART COLLECTION RULES: - Common rule columns: TAG, VENDOR, TYPE, TITLE, VARIANT_PRICE. - Common relations: EQUALS, NOT_EQUALS, CONTAINS, NOT_CONTAINS, STARTS_WITH, ENDS_WITH, GREATER_THAN, LESS_THAN. - `appliedDisjunctively: true` means products matching ANY rule are included (OR logic). - `appliedDisjunctively: false` means products must match ALL rules (AND logic). IMAGE REQUIREMENTS: - Images must be publicly accessible HTTPS URLs (e.g. https://example.com/photo.jpg). - Local file paths (e.g. /mnt/data/..., file://...) are NOT supported and will fail. - If you only have a local file or a generated image, ask the user for a publicly accessible HTTPS URL; this host cannot upload one. - Avoid placeholder or non-deterministic image URLs (e.g. picsum.photos) for real collections.

Retrieve detailed information about a specific Shopify collection by its GID, including title, description, image, products, and rules (for smart collections). MUST be called whenever the user refers to a collection they own or previously created — regardless of phrasing. Trigger phrases include: "my collection", "that collection", "the collection", "show me my collection", "get my collection", or any reference to a previously created or known collection. "Show" and "get" mean the same thing here: always fetch live data from Shopify. Do NOT rely on memory or prior responses — always call this tool for the source of truth.

Update an existing collection's title, description, image, sort order, or rules. Use this when the user wants to modify, change, or edit collection details. Trigger phrases include: "update my collection", "change the collection", "edit the collection", "rename the collection". IMAGE REQUIREMENTS: - Images must be publicly accessible HTTPS URLs (e.g. https://example.com/photo.jpg). - Local file paths (e.g. /mnt/data/..., file://...) are NOT supported and will fail. - If you only have a local file or a generated image, ask the user for a publicly accessible HTTPS URL; this host cannot upload one. - Avoid placeholder or non-deterministic image URLs (e.g. picsum.photos) for real collections. SMART COLLECTION RULES: - Pass `ruleSet` to update the rules for a smart collection. - Common rule columns: TAG, VENDOR, TYPE, TITLE, VARIANT_PRICE. - Common relations: EQUALS, NOT_EQUALS, CONTAINS, NOT_CONTAINS, STARTS_WITH, ENDS_WITH, GREATER_THAN, LESS_THAN. - Passing `ruleSet` replaces all existing rules. Omitting it leaves rules unchanged.

Create a draft product through Shopify Digital Products. The result includes the product and first variant identifiers used to attach and deliver the digital file. To set the price and the buyer-facing description, call update-product with productId as its 'id' and variantId in 'variants' — prices are in the shop's own currency, so ask the merchant for the amount rather than guessing one. Do not rename the product through update-product: Digital Products keeps its own copy of the title. This tool does not publish the draft.

Create a draft digital product that delivers an external link to the buyer — a Notion template, an online course, a booking page. Use this instead of create-digital-product when the merchant is selling access to something that already lives on the web, and skip the file upload entirely. The link must be hosted by a provider Shopify Digital Products supports; if it is not, the reply names the ones that are. To set the price and the buyer-facing description, call update-product with productId as its 'id' and variantId in 'variants' — prices are in the shop's own currency, so ask the merchant for the amount rather than guessing one. This tool does not publish the draft.

Show the merchant a card for a digital product: its media image, title, price, status, and what the buyer receives. Call this after each step of the digital product flow — after the price is set, after the file is attached, after the media image is added, and after publishing — so the merchant sees the listing as it stands. Every field is read back from Shopify, so the card is current rather than a summary of what was asked for. This only reads. It changes nothing about the product.

Report whether the Digital Products app is installed on the authenticated store. Call this once after the merchant says they have finished the Shopify Admin install flow that open-digital-products-install handed them. Do not poll it.

Execute a GraphQL mutation against the Shopify Admin API when no dedicated built-in tool covers the request. Before execution, call graphql_schema with operation 'mutation' to discover the exact mutation field and its arguments. Then use operation 'schema' and type_name to inspect unfamiliar input and return types, following nested named types as needed. Never guess fields. search_docs_chunks can supplement discovery with examples but never replaces it. Some dangerous mutations are blocked for safety (e.g. refunds, gift card writes, staff management, theme deletion, theme publishing). Theme file writes (themeFilesCopy, themeFilesUpsert) are allowed on unpublished themes only — writes that target the live/MAIN theme are blocked. If a mutation is blocked, inform the user and suggest they perform the action in Shopify admin. After constructing the mutation, call this tool to execute it. The host app will prompt the user for confirmation before executing. setup-mcp also validates the operation against its pinned Admin schema before sending it to Admin. After executing, present the results clearly rather than dumping raw JSON.

Execute a read-only GraphQL query against the Shopify Admin API when no dedicated built-in tool covers the request. Raw schema introspection (__schema / __type) is not allowed through this tool. Use graphql_schema with operation 'query' to find an unknown query field or inspect its arguments and return type. Use operation 'schema' and type_name only for unfamiliar types needed by the query, including custom scalars whose value formats are unknown. Reuse schema details already discovered; skip built-in scalars (String, Int, Float, Boolean, ID). Never guess fields. After constructing the query, call this tool to execute it. The server validates Admin GraphQL against its pinned schema before sending the query to Admin. search_docs_chunks supplements schema discovery with examples but cannot replace it. For pagination select pageInfo { hasNextPage endCursor }, then use the returned endCursor as the after variable. Present results clearly to the user rather than dumping raw JSON. For writes, discover the operation with graphql_schema using operation 'mutation', then use graphql_mutation.

Discover queries, mutations, and named types in the Shopify Admin GraphQL schema. This tool only inspects the schema; it never executes an operation. Every call needs operation or type_name; a call with neither is rejected. Set operation to 'query' or 'mutation' to list top-level field names, optionally filtered by a case-insensitive search. Supply an exact field_name to inspect its arguments, return type, and description; skip the name list if the field is already known. Set operation to 'schema' and type_name to a namedType returned by discovery to inspect one named type. Objects and interfaces list field names and return types; input objects list input fields and isOneOf without recursively expanding nested types. Enums list values, and unions/interfaces list possible types. Supply field_name for one field's or enum value's details. Inspect only unfamiliar types needed by the operation, including custom scalars whose formats are unknown. Reuse discovered details and skip built-in scalars (String, Int, Float, Boolean, ID). Never guess fields. QueryRoot and Mutation must be discovered with operation 'query' or 'mutation'. After constructing an operation, call graphql_query or graphql_mutation to execute it. Those execution tools validate before sending the operation to Admin. search_docs_chunks supplements discovery with examples but never replaces it. Documentation questions go straight to search_docs_chunks.

Create a new product in the connected Shopify store. If create-product-interactive is available, prefer it over create-product. Use this when the user wants to add a product with a title, description, variants, images, or other product details. VARIANTS & OPTIONS: - When providing `variants`, you MUST also provide the `options` field as a string array of option names. - Example: for a single default variant use `options: ['Title']`, for Size/Color variants use `options: ['Size', 'Color']`. - The `options` field must be an array of strings (e.g. `['Size', 'Color']`), NOT an array of objects. - Each variant's `optionValues` must reference option names declared in the `options` array. INVENTORY TRACKING: - To enable inventory tracking on variants, set `inventoryItem: { tracked: true }` on each variant. - If omitted, inventory defaults to untracked and set-inventory will not work as expected. IMAGE REQUIREMENTS: - Images must be publicly accessible HTTPS URLs (e.g. https://example.com/photo.jpg). - Local file paths (e.g. /mnt/data/..., file://...) are NOT supported and will fail. - If you only have a local file or a generated image, ask the user for a publicly accessible HTTPS URL; this host cannot upload one. - Avoid placeholder or non-deterministic image URLs (e.g. picsum.photos) for real products. - The first image provided becomes the product's featured image. COLLECTION: - Optionally pass `collectionId` to add the product to a collection after creation. - To add to multiple collections, use add-to-collection afterward.

Retrieve detailed information about a specific Shopify product by its GID, including title, status, vendor, variants, images, tags, and inventory. MUST be called whenever the user refers to a product they own or previously created — regardless of phrasing. Trigger phrases include: "my product", "that product", "the product", "show me my product", "get my product", "pull up the product", "open my product", or any reference to a previously created or known product. "Show" and "get" mean the same thing here: always fetch live data from Shopify. Do NOT rely on memory or prior responses — always call this tool for the source of truth.

Update an existing product's title, description, status, images, variant pricing, or variant option values (e.g. color, size names). Use this when the user wants to modify, change, or edit product details — including status, variant prices, option values, or images. Trigger phrases include: 'update my product', 'change the price', 'edit the product', 'modify my product', 'rename the variant', 'change the color name'. IMAGE REQUIREMENTS: - Images must be publicly accessible HTTPS URLs (e.g. https://example.com/photo.jpg). - Local file paths (e.g. /mnt/data/..., file://...) are NOT supported and will fail. - If you only have a local file or a generated image, ask the user for a publicly accessible HTTPS URL; this host cannot upload one. - Avoid placeholder or non-deterministic image URLs (e.g. picsum.photos) for real products. REPLACING IMAGES: - To replace specific images, first use get-product to find the mediaId of the image(s) to remove. - Pass those mediaId values in removeMediaIds, and provide the new images in the images array. - To remove images without adding new ones, pass removeMediaIds without images.

Generate business name ideas for someone starting a Shopify store. WHEN TO USE: - The user wants name ideas for a new business or store. - The user has described a business but has not named it yet. - The user has a name and wants alternatives in the same vein. WHEN NOT TO USE: - The user already knows the name they want and only needs to set it — that is done in the Shopify admin, not here. - The user wants a product name, a slogan, or a tagline rather than a business name. INPUT: a short description of the business in the user's own words — what they sell, who it is for, or the feeling they want ('hand-poured soy candles for dark, woody scents'). Max 255 characters. Pass what the user actually said; do NOT invent a business they have not described. Every name comes back with a `signupUrl`, the link that acts on it, so present it rather than describing it. Where it goes depends on the user: with no Shopify store connected it opens store signup with the name already filled in; with a store connected it opens the store name setting in that store's Shopify admin, where they save the new name themselves. Either way the tool only hands back a link — it creates and renames nothing. A store name is not exclusive, so the user can take any of these for their store. Nothing here is verified, though — no trademark search, no business registry, no check of whether someone else is already trading under the name — so tell them to check that before building a brand on it.

Suggest available domain names for a Shopify store. Every domain returned has been checked against the domain registry and was available at the time of the call. WHEN TO USE: - The user wants a domain for a business or store name. - The user's preferred domain is taken and they want alternatives. - The user asks whether a domain idea is available. - The user wants to know what a domain costs. - The user wants to buy or register a particular domain. WHEN NOT TO USE: - The user wants to connect or troubleshoot a domain they already own — that is done in the Shopify admin, not here. - The user only wants store-name ideas and does not care whether a domain is available or what it costs. INPUT: a store name, a domain the user has in mind, or a short description of the business. All three work. If the user named a domain, the tool checks that exact domain, checks the same name at other common TLDs, and also returns 3 alternatives. An unusual TLD is fine — keep the one the user said. Pass the domain on its own as the query, or — when it sits inside a sentence — put it in exactDomain. If the user named no domain, put the words the domain should be built from in storeName: a name the user proposed ('volcanic balloon', 'Ember & Oak'), or the subject of what they described ('a domain about hippos, giraffes, and iguanas' → 'hippos giraffes iguanas'). Four words at most, lead-in and connecting words dropped, in the user's own words rather than converted to a domain yourself. The tool compresses them into a domain and checks that the same way; without storeName there is no availability check for a query like that, only suggestions. Only the exact domain checked can come back unavailable. Every other domain returned is available to buy, so do not describe any of them as taken, and do not say which TLDs were checked — an unlisted TLD may have been taken or may not have been quoted, and you cannot tell which. Every domain on offer carries a `signupUrl`, the one link that buys it, so present it rather than describing it. Where it leads depends on whether a Shopify store is connected to the call, not on whether the user owns one. With a store connected, it opens that domain's purchase page in that store's Shopify admin, so buying it attaches the domain to the store rather than starting a second one; the response says when this applies. Without one, it opens store signup with the domain already selected, even for a user who says they already have a store. Availability is a point-in-time check, not a hold. Tell the user to register a domain they want promptly, and never promise a domain is still available later in the conversation. Prices, where present, are the registry's quote for the first registration term in the stated currency. Renewal is priced separately and is often higher, so present a price as what registering costs today, not as an ongoing rate. A domain can come back without a price; say nothing about its cost rather than guessing, and in particular do not read a missing price as a domain that costs nothing. Every domain here has to be bought. Say a domain is "available" or "unavailable" — never that it is "free", which states a price rather than an availability and states it wrongly.

Retrieve inventory levels for all variants of a product across locations. Use this when the user asks about stock quantities, inventory availability, or wants to see how much inventory is at each location for a given product.

Set the available inventory quantity for a specific inventory item at a given location. Always call get-inventory-levels first to get the inventoryItemId, locationId, and current available quantity. Pass the current quantity as compareQuantity so the update fails safely if stock changed since you read it.

Give the merchant a Shopify Admin link for attaching the downloadable file to a digital product they have already created. Call this after create-digital-product, passing back the product and variant identifiers it returned. This host cannot take a file from the merchant, so the attachment is finished in the Digital Products app rather than here. Relay the link this returns and ask the merchant to report back here once the upload is done; nothing tells this conversation on its own. This does not create products and does not publish anything.

Give the merchant a Shopify Admin link for adding a media image to a digital product they have already created. Ask the merchant whether they want a media image first, and only call this if they say yes. A digital product sells perfectly well without one. This host cannot take an image from the merchant, so it is added on the product's page in Shopify Admin rather than here. Relay the link this returns and ask the merchant to report back here once the image is added; nothing tells this conversation on its own. This does not change the price, description, attached file or status, and it does not publish anything.

Run a ShopifyQL analytics query. Returns tabular results with automatic chart visualization. IMPORTANT: Always use FROM...SHOW syntax. Use TIMESERIES for time charts, GROUP BY for categories. ## Sales & Revenue - FROM sales SHOW gross_sales TIMESERIES day SINCE -30d UNTIL today - FROM sales SHOW orders, gross_sales, discounts, sales_reversals, net_sales, shipping_charges, taxes, total_sales TIMESERIES day SINCE -30d UNTIL today - FROM sales SHOW total_sales TIMESERIES day SINCE -30d UNTIL today COMPARE TO previous_period - FROM sales SHOW gross_sales, discounts, sales_reversals, net_sales, shipping_charges, taxes, total_sales - FROM sales SHOW average_order_value TIMESERIES day SINCE -30d UNTIL today ## Orders - FROM sales SHOW orders TIMESERIES day SINCE -7d UNTIL today - FROM fulfillments SHOW orders_fulfilled, orders_shipped, orders_delivered TIMESERIES day SINCE -30d UNTIL today ## Products - FROM sales SHOW gross_sales, net_sales, orders GROUP BY product_title ORDER BY gross_sales DESC LIMIT 10 - FROM inventory SHOW starting_inventory_units, ending_inventory_units, inventory_units_sold, sell_through_rate GROUP BY product_title, product_variant_title ## Customers - FROM sales SHOW returning_customers, customers, returning_customer_rate TIMESERIES day SINCE -30d UNTIL today - FROM sales SHOW new_customers, returning_customers TIMESERIES day SINCE -30d UNTIL today ## Sessions & Conversion - FROM sessions SHOW sessions, online_store_visitors TIMESERIES day SINCE -30d UNTIL today - FROM sessions SHOW sessions, sessions_with_cart_additions, sessions_that_reached_checkout, sessions_that_completed_checkout, conversion_rate TIMESERIES day SINCE -30d UNTIL today - FROM sessions SHOW sessions GROUP BY session_device_type SINCE -30d UNTIL today - FROM sessions SHOW sessions GROUP BY session_country SINCE -30d UNTIL today ## Marketing & Referrals - FROM sales SHOW orders, total_sales GROUP BY order_referrer_source, order_referrer_name SINCE -30d UNTIL today - FROM sessions SHOW sessions WHERE referrer_source = 'social' GROUP BY referrer_name SINCE -30d UNTIL today ## Tables: sales, sessions, customers, fulfillments, inventory, payments. There is no orders table: count orders with FROM sales SHOW orders ## Time grouping: TIMESERIES day/week/month. Category grouping: GROUP BY column ## Comparison: COMPARE TO previous_period. Aggregates: WITH TOTALS, PERCENT_CHANGE

Update the status of multiple products at once. Accepts a list of product IDs or a collectionId and a target status (ACTIVE, DRAFT, or ARCHIVED). Each product is updated individually so partial failures are possible. When using collectionId, only the first 50 products in the collection will be updated.

Search and browse collections on a Shopify store. Use this whenever the user wants to see, find, or look at collections in their store. Trigger phrases include: 'show me my collections', 'what collections do I have', 'list my collections', 'find a collection', 'search collections', or any reference to viewing multiple collections. 'Show' and 'get' mean the same thing: always fetch live data from Shopify. Do NOT summarize from memory. Use this when the user wants to: - list or search collections - find a collection by name - check what collections exist in their store - find a collection GID to use with add-to-collection or create-product Returns collection data from the connected store via the Shopify Admin API. Results are capped at 50 per call. When `pageInfo.hasNextPage` is true, more matches exist than were returned. Tell the user you are showing the first N results and offer two paths: (a) load more via `after: pageInfo.endCursor`, or (b) refine the search with a stricter query. Only act on one of those paths when the user asks; do not auto-paginate. SEARCH SYNTAX: Free text matches across default fields (e.g. `summer`, `"new arrivals"`). Field filters use `field:value`. Combine with `AND` / `OR` / `NOT`; parenthesize subqueries. Ranges use `:<`, `:<=`, `:>`, `:>=` on numeric/date fields. Example: `collection_type:smart AND title:sale*`. IMPORTANT — invalid field names are silently ignored and return everything. Only use the fields listed below, as flat names. Do NOT invent dotted paths like `collection.title` or `rules.column`. Supported filter fields: - Text / exact: `title`, `handle`, `collection_type` (custom|smart) - Numeric (support ranges): `id` - Date (support ranges): `updated_at`, `published_at` — use ISO 8601 in quotes, e.g. `updated_at:>'2024-01-01'` - ID: `product_id` (collections containing the given product) - Publication: `published_status` (e.g. `published`, `unpublished`, `online_store_channel`) Note: there is no server-side filter for product count, rules, or sort order. For those, filter by `collection_type` and inspect the returned `productsCount` / `sortOrder` fields client-side, or narrow with `title:` / `handle:`.

Retrieve a list of customers from the connected Shopify store, including name, email, phone, order count, and total spent. Use this when the user asks about their customers, wants to look up a specific customer, or needs customer data for analysis. SEARCH SYNTAX: When the user is looking for a specific customer (by name, email, tag, etc.), ALWAYS pass a structured `query` using Shopify's customer search syntax. Do NOT pass a bare free-text term like `Smith` for a name search — Shopify's default fields match addresses, tags, company names, and notes, which returns unrelated customers. Field filters use `field:value`. Combine with `AND` / `OR` / `NOT`; parenthesize subqueries. Ranges use `:<`, `:<=`, `:>`, `:>=` on numeric / date fields. Name lookups should query BOTH first and last name, e.g. for "customers named Smith" use `first_name:Smith OR last_name:Smith`. Supported filter fields: - Name: `first_name`, `last_name` - Contact: `email`, `phone` - Location: `country` (full name or code, e.g. `Canada` / `CA`) - Account state: `state` (`enabled` | `invited` | `disabled` | `declined`) - Marketing: `accepts_marketing` (boolean), `email_marketing_state` (`subscribed` | `not_subscribed` | `pending` | `invalid` | `redacted`) - Tags: `tag`, `tag_not` - Numeric (support ranges): `orders_count`, `total_spent`, `id` - Date (support ranges): `created_at`, `updated_at`, `order_date`, `last_abandoned_order_date` — use ISO 8601 in quotes, e.g. `created_at:>'2024-01-01'` RECENCY OF ORDERS: To filter by when a customer placed an order, use `order_date` — NOT `updated_at`. `order_date` matches customers who have at least one order within the given date range. `updated_at` is bumped by profile edits too, so it's a leaky proxy. For abandoned-checkout recency, use `last_abandoned_order_date`. Compose either with the same date syntax shown for `created_at` / `updated_at` above; for relative windows ("last N days"), compute the cutoff from the current date in your context. Examples: - `Find customers named Smith` → `first_name:Smith OR last_name:Smith` - `Customers with gmail addresses` → `email:*@gmail.com` - `Customers with more than 5 orders` → `orders_count:>5` - `Customers from Canada` → `country:Canada` - `VIP customers` → `tag:vip` - `Subscribed to email` → `email_marketing_state:subscribed` IMPORTANT — invalid field names are silently ignored and return everything. Only use the fields listed above. Do NOT invent fields like `name:`, `full_name:`, `customer_name:`, or `city:`.

Create a percentage-based discount code for the connected Shopify store. Use this when the merchant wants to set up a new discount code with a specific percentage off — including one limited to particular products or to a collection — with optional minimum purchase or quantity requirements. SCOPE — what the discount applies to: - Call both search_products and search_collections on whatever the merchant named, even if the first one already matches — a product and a collection can share a name. If both match, ask the merchant which they meant rather than picking one. - Specific products ("20% off the Snake Plant", "put these three items on sale"): pass productIds with their product GIDs, up to 50 of them. Look the GIDs up with search_products or get-product first. - An existing collection ("20% off everything in Summer Sale"), or any set larger than 50 products: pass collectionId. - Every product in the store: omit both. - productIds and collectionId are mutually exclusive. Passing both is rejected before anything is created. Do NOT create a collection just to scope a discount to products. This tool discounts products directly in one call, so a collection made only as a stepping stone leaves the merchant with one they never asked for. This is not a restriction on create-collection itself: if the merchant asked for a collection, create it and then scope the discount to it with collectionId. What matters is why the collection exists — one the merchant wants is fine, one invented to work around productIds is not. BEFORE CALLING — get two answers from the merchant, in one message if both are missing. Do not call this tool until you have both, and do not fill either in yourself: there is no default start date and no default audience. - When the discount starts: right away, or on a specific date. Pass startsAt as an ISO 8601 timestamp: the current date and time for "right away", or the date the merchant chose. - Who can use it: every customer, or only certain customer segments. Pass customerEligibility="all_customers" once the merchant confirms everyone, or customerSegments with the names of segments that exist on this store. One exception: if the merchant wants the discount limited to a customer segment and you do not know which segments this store has, call with startsAt set and both customerEligibility and customerSegments omitted. Nothing is created; the tool replies with the store's segment names. Show them to the merchant, then call again with the one they choose.

This tool will take in the user prompt, search shopify.dev, and return relevant documentation and code examples that will help answer the user's question.

Copy a mock.shop sample catalog's starter set — its first 2 collections and up to 8 products from each (with variants, prices, images), so at most 16 products — into the merchant's connected store, publishing everything to the Online Store. Use it after the merchant picks a catalog from find-mock-shop-catalogs. One call does the whole import. RE-RUNNING IS SAFE AND NEVER OVERWRITES: calling again (after a timeout or `partial: true`) adds only what is missing — products not yet imported, memberships and publications not yet made. A product already imported from this catalog is left exactly as it is — including any edits the merchant has made since, and including whether it is published — and counted under `unchanged`; if it is not published, it is listed under `unpublished` for the merchant to publish or delete in Admin. A product the merchant already has at the same handle from elsewhere is left untouched and reported under `skipped`. A collection the merchant already has at the same handle is reused when its title matches the catalog's (missing imported products are added to it) and skipped when it does not. Collections are created only with their imported products, so none is ever left empty. INPUT: `subdomain` from the chosen catalog (e.g. "pets"). Nothing else. OUTPUT: counts of products created/unchanged/skipped and collections created/reused/skipped, and `currency`. If `partial` is true Shopify rate-limited the call: wait a few seconds, then call again with the same `subdomain`. Prices are copied as plain amounts; when `currency.mismatch` is true tell the merchant prices came from a ${currency.source} catalog and were not converted, so they should review them.

Find ready-made sample catalogs (from mock.shop) that fit the merchant's business, so they can pick one to seed their store with realistic products and collections instead of starting empty. WHEN TO USE: - The merchant has a new or empty store and wants sample products, a starter catalog, demo data, or "something to look at" before adding their own products. - The merchant describes what they sell (or plan to sell) and wants a store populated quickly. WHEN NOT TO USE: - The merchant wants one-off placeholder products rather than a whole catalog — use find-sample-product. - The merchant wants real products to source or resell — this returns sample data, not supplier inventory. - The merchant wants to browse products already in their store — use search-products. INPUT: a short description of the business or what it sells (e.g. "handmade soy candles", "supplies for a new puppy", "streetwear for teens"). Take it from what the merchant said. If they gave no hint at all, ask one question — what do they plan to sell? — then call. OUTPUT: up to `limit` catalogs (default 3), best match first. Each has a name, short description, categories, collection titles, product and collection counts, currency, and a `storefrontUrl` the merchant can open to browse it as a live storefront. Present them as a short list with the storefront links and ask the merchant which one they want. Pass the chosen catalog's `subdomain` to import-mock-shop-catalog to copy it into their store. An empty list means nothing matched well — suggest the merchant describe their business differently.

Get a Shopify Admin install link for Digital Products on the authenticated store. Use this only after the merchant has explicitly asked to install or prepare Digital Products for their store. The app identity is fixed by Shopify; this tool cannot install arbitrary apps and does not install anything silently. Relay the link to the merchant and ask them to come back here once the install is done. They must complete the Shopify Admin install flow before Digital Products connector tools can continue; call get-digital-products-install-status once they say they have.

Retrieve detailed information about a specific Shopify order including line items, fulfillment status, shipping address, and tracking. Use this when the user asks about a particular order's details or status.

Retrieve recent orders from the connected Shopify store. Returns order name, customer, totals, financial and fulfillment status. Use this when the user asks about their orders, wants an overview of recent sales, or needs to find a specific order.

Search and browse products on a Shopify store. MUST be called whenever the user wants to see, find, or look at products in their store. Trigger phrases include: 'show me my products', 'what products do I have', 'list my products', 'browse my catalog', 'find a product', 'search for', or any reference to viewing multiple products. 'Show' and 'get' mean the same thing: always fetch live data from Shopify. Do NOT summarize from memory. Use this when the user wants to: - list or search products - look up a specific product by ID or handle - check product status or details - browse what's in their catalog Returns product data from the connected store via the Shopify Admin API. Results are capped at 50 per call. When `pageInfo.hasNextPage` is true, more matches exist than were returned. Tell the user you are showing the first N results and offer two paths: (a) load more via `after: pageInfo.endCursor`, or (b) refine the search with a stricter query. Only act on one of those paths when the user asks; do not auto-paginate. SEARCH SYNTAX: Free text matches across default fields (e.g. `shoes`, `"green hoodie"`). Field filters use `field:value`. Combine with `AND` / `OR` / `NOT`; parenthesize subqueries. Ranges use `:<`, `:<=`, `:>`, `:>=` on numeric/date fields. Example: `price:<=25 AND status:active`. IMPORTANT — invalid field names are silently ignored and return everything. Only use the fields listed below, as flat names. Do NOT invent dotted paths like `variants.price`, `product.tag`, or `variant.sku`. Supported filter fields: - Text / exact: `title`, `vendor`, `product_type`, `handle`, `sku`, `barcode`, `variant_title`, `tag`, `tag_not`, `status` (active|archived|draft) - Numeric (support ranges): `price` (matches products with ANY variant whose price satisfies the condition), `inventory_total`, `id`, `variant_id` - Date (support ranges): `created_at`, `updated_at`, `published_at` — use ISO 8601 in quotes, e.g. `created_at:>'2024-01-01'` - Boolean: `gift_card`, `bundles`, `is_price_reduced`, `out_of_stock_somewhere`, `tracks_inventory`, `has_only_default_variant` - ID: `collection_id`, `category_id` Price examples (cross-variant semantics): - `price:<=25` — products with at least one variant priced $25 or less - `price:>100 price:<=500` — products with at least one variant in $100–$500 - `price:25` — products with at least one variant priced exactly $25 SHOULD populate `search_summary` with a concise but descriptive plain-text heading in the user's language. Use a noun phrase that identifies the results as products instead of repeating only the search term—for example, "Your sneaker products", not "Your sneakers". The widget displays this text verbatim, so do not use Markdown. For a min/max of every variant or a product-wide price band, this tool cannot express it server-side; tell the user and suggest narrowing with `price:` plus another filter (e.g. `product_type:`, `vendor:`, `tag:`).

Take a draft digital product live through Shopify Digital Products, so buyers can purchase and download it. Activates the product and requests its Online Store listing. Refuses to publish a product with nothing attached, so attach the file first with upload-digital-product-file. Digital Products does not report whether the Online Store listing succeeded, so tell the merchant to check the product in their Online Store if buyers cannot find it.

Retrieve basic information about the connected Shopify store including name, domain, email, plan, currency, timezone, and country. Use this when you need store context to tailor advice (e.g. plan limitations, currency for pricing, timezone for scheduling), when the user asks about their store details, or to verify which store is connected.

Switch to a different Shopify store. Call this tool whenever the user wants to work with a different store — including when they ask to fetch data, manage products, or perform any action on another shop. Revokes the current store's access token so the next tool call will prompt authorization for a new store. IMPORTANT: You must always make a follow-up tool call after this tool returns. If the user requested a specific action (e.g. fetch products), call that tool next. Otherwise, you MUST call get-shop-info to complete the shop switch.

Verify that the connected store can exchange its Admin token and reach the Digital Products connector. This read-only check returns no credentials or connector data.

Compatibility no-op for clients that still call this tool. It always returns success and does not validate GraphQL syntax or schema. For Admin GraphQL, graphql_query and graphql_mutation validate operations against setup-mcp's pinned Admin schema immediately before execution.