Shopify Data MCP (MRSLM Data)

MCP-Server für KI-Agenten: Produkte, Preise, Lagerbestand und Kollektionen in jedem öffentlichen Shopify-Shop durchsuchen, den Tech-Stack von Shops erkennen, App-Infos aus dem Shopify App Store lesen und Produktdaten von jeder Produktseite extrahieren. 5 $ pro 1.000 Tool-Aufrufe über Apify; kein Store-API-Schlüssel erforderlich.

Auf apify.com ansehen

Gehosteter MCP-Server

npx add-mcp 'https://mrslm-data--shopify-data-mcp-server.apify.actor/mcp'

Installiert in Claude Code, Codex, Cursor und mehr

Dokumentation

Shopify MCP Server: Products & Prices for AI Agents (`mrslm_data/shopify-data-mcp-server`) Actor

MCP server that lets Claude, ChatGPT, Cursor and other AI agents search products, prices, stock and collections in any public Shopify store. Pay per call.

URL: https://apify.com/mrslm_data/shopify-data-mcp-server.md
Developed by: shawn slam (community)
Categories: AI, E-commerce, MCP servers
Stats: 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
User rating: No ratings yet

Pricing

from $4.00 / 1,000 tool calls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the API section below.

Each client library has reference documentation the quickstart does not restate: JavaScript/TypeScript (npm install apify-client) and Python (pip install apify-client).

README

Shopify MCP Server: Products & Prices for AI Agents

Give Claude, ChatGPT, Cursor or your own agent live public Shopify data through MCP: product search, product details, collections, store tech stack, Shopify App Store app info and any product page. $0.005 per tool call.

Quick start

Press Start. The form is already filled with this example input, so the first run returns real rows in under a minute:

{
  "tool": "shopify_search_products",
  "arguments": {
    "store": "allbirds.com",
    "query": "runner",
    "limit": 5
  }
}

Swap in your own values, or call the Actor through the Apify API, Make, Zapier, n8n or the Python/JS clients with the same JSON.
Download the results as JSON, CSV or Excel from the Output tab, or schedule the run to repeat.

Full guide: How to Connect a Shopify MCP Server to Claude, ChatGPT or Cursor for Live Product and Price Data

What the Shopify MCP Server does

The Actor is a remote MCP server running in Apify Standby mode at https://mrslm-data--shopify-data-mcp-server.apify.actor/mcp. It speaks MCP over Streamable HTTP and offers six read-only tools. It reads only what stores publish to every visitor, the public Shopify catalog JSON and public pages, so you need no Shopify API key and no store access, only your Apify token.

You can also start it as a normal run: pick one tool and its arguments, or list up to 50 calls. Each call becomes one dataset row with the tool name, the arguments, ok, the result (or an error) and the time.

shopify_search_products: a store's products, with optional text query, collection and on-sale filter (store required; limit 1 to 100, default 20).
shopify_get_product: one product with every variant, SKU, price, compare-at price and stock (by product URL, or store plus handle).
shopify_list_collections: a store's collections with product counts (limit up to 250, default 50).
shopify_detect_store: whether a site runs on Shopify, plus theme, currency, country, detected apps and social links.
shopify_app_info: a Shopify App Store listing: developer, rating, review count, pricing plans, categories, languages and integrations.
product_page_extract: name, brand, SKU, GTIN, price, stock and rating from a product page on any platform.

Who it is for

AI agent builders: give a shopping, research or sales agent live store data without writing scrapers.
Ecommerce analysts: ask an assistant to compare competitors' catalogs, prices and tech stacks in plain language.
Shopify app makers and agencies: have an assistant look up a store's theme and apps, or a rival app's rating and pricing plans.
Developers: call the same tools in batch from code, with one row per call.

Real example: three tool calls on Allbirds and Judge.me

Say you are preparing a sales call with Allbirds and want three facts: what the store runs on, what its runner shoes cost, and what the Judge.me app it might use costs. In an agent you would just ask; here you run the three calls in one batch.

Step 1: Enter the input

Open the Shopify MCP Server in Apify Console, switch the input form to JSON and paste this. It is the exact input used for the run in this guide:

{
  "calls": [
    {
      "tool": "shopify_detect_store",
      "arguments": {
        "url": "allbirds.com"
      }
    },
    {
      "tool": "shopify_search_products",
      "arguments": {
        "store": "allbirds.com",
        "query": "runner",
        "limit": 3
      }
    },
    {
      "tool": "shopify_app_info",
      "arguments": {
        "app": "judgeme"
      }
    }
  ]
}

What each setting does:

calls: three tool calls, each with a tool name and its arguments. For a single call you can use the top-level tool and arguments fields instead.

Step 2: Run it

Press Start. On 30 October 2026 this input finished with status SUCCEEDED in about 7 seconds and saved 3 rows to the run's dataset. The run was charged 3 tool-call events plus one start event, so the bill was $0.015 on the Free/Bronze tier. The summary shows 3 calls, 3 ok and 0 failed.

Step 3: Read the output

Here are the first rows of the real dataset, cut to the most useful columns:

tool	arguments	ok
shopify_detect_store	{"url": "allbirds.com"}	yes
shopify_search_products	{"store": "allbirds.com", "query": "runner", "li…	yes
shopify_app_info	{"app": "judgeme"}	yes

And one full row as JSON (long text shortened with …):

{
  "tool": "shopify_app_info",
  "arguments": {
    "app": "judgeme"
  },
  "ok": true,
  "result": {
    "handle": "judgeme",
    "url": "https://apps.shopify.com/judgeme",
    "name": "Judge.me Product Reviews App",
    "description": "Send unlimited, automatic review requests via email, SMS, and push. Display stars and reviews on storefront, share reviews on social media and Google Shopping.",
    "developer": "Judge.me",
    "developerUrl": "https://apps.shopify.com/partners/judge-me",
    "rating": 5,
    "reviewCount": 49362,
    "pricingPlans": [
      {
        "name": "Forever Free",
        "price": "Free",
        "note": null,
        "features": [
          "Unlimited product and store reviews",
          "Unlimited visual reviews (photos/videos)",
          "Review widget & star rating badge",
          "Carousels (Video, Cards, Testimonials)",
          "…"
        ]
      },
      {
        "name": "Awesome",
        "price": "$15 / month",
        "note": null,
        "features": [
          "AI (replies, summary, translations)",
          "130+ integrations, inc. Klaviyo, Gorgias",
          "16 widgets (Snippets, Q&A, Reviews Page)",
          "Advanced collection (auto-reminder, etc)",
          "…"
        ]
      }
    ],
    "hasFreePlan": true,
    "launched": "June 25, 2015",
    "languages": [
      "English",
      "Spanish",
      "French",
      "Italian",
      "…"
    ],
    "worksWith": [
      "Checkout",
      "Customer accounts",
      "Shopify Flow",
      "Shopify Admin",
      "…"
    ],
    "categories": [
      "Product reviews",
      "SEO"
    ],
    "features": [
      "Testimonials",
      "Photo reviews",
      "Video reviews",
      "Star ratings",
      "…"
    ],
    "iconUrl": "https://cdn.shopify.com/app-store/listing_images/8cada0f5da411a64e756606bb036f1ed/icon/CIfp9fWd34sDEAE=.png"
  },
  "error": null,
  "calledAt": "2026-10-30T16:17:25.622Z"
}

The sample above is the shopify_app_info row (lists are trimmed to four entries). What the three real results show:

shopify_detect_store on allbirds.com: Shopify, found from three signals (the powered-by header, the _shopify cookie and Shopify CDN assets). The myshopify domain is weareallbirds.myshopify.com, the theme is allbirds-theme version 1.231.12, currency USD and country US, and agenticCommerceUcp is true. Seven apps and tools were detected: Attentive (email and SMS), Loop Returns, Google Tag Manager, Microsoft Clarity, Triple Whale, Elevar and OneTrust. It also returned the store's Instagram, Pinterest, Facebook, X, TikTok and YouTube links.
shopify_search_products for "runner", limit 3: the tool scanned 13 products to find 3 matches: the Men's and Women's Canvas Runner NZ in Deep Navy Stripes and the Men's Tree Runner in Jet Black, all $100, available and not on sale, with 13, 13 and 7 size variants. Each product also carries its tags, options, image and created, updated and published dates.
shopify_app_info for judgeme: Judge.me Product Reviews App by Judge.me, rated 5 with 49,362 reviews, launched June 25, 2015, in the Product reviews and SEO categories, available in 15 languages, with a Forever Free plan and an Awesome plan at $15 a month. It lists 10 integrations, such as Klaviyo, Gorgias and Shopify Flow. It does not return individual reviews or reviewer names.

Connect it to your AI assistant

Add the server to any MCP client that supports remote servers over Streamable HTTP, such as Cursor, VS Code, Claude (through a custom remote connector) or an agent framework with MCP support:

{
  "mcpServers": {
    "shopify-data": {
      "url": "https://mrslm-data--shopify-data-mcp-server.apify.actor/mcp",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}

Put your own Apify token in place of <YOUR_APIFY_TOKEN>. The same URL is on the Actor's Standby tab. Then ask things like "What does gymshark.com sell under $30 that is on sale?" or "Which apps does this store use, and what do they cost?", and the assistant picks the tools itself.

To check the connection without a client, list the tools with one request. This is a free call; only tool calls are charged:

curl -X POST https://mrslm-data--shopify-data-mcp-server.apify.actor/mcp \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

We ran this request on 30 October 2026 and it returned all six tools with their input schemas. The server is stateless, so each POST stands alone. All tools are marked read-only.

Output fields

Each row in the dataset has these fields. The example column shows a value from the run above.

Field	What it means	Example from this run
`tool`	The tool that was called.	shopify_detect_store
`arguments`	The arguments you passed.	{"url": "allbirds.com"}
`ok`	true when the call succeeded.	yes
`result`	The tool's result object (different for each tool).	{"url": "https://www.allbirds.com/", "httpStatus": 200, "isS…
`error`	Why the call failed, or null.	(empty in this run)
`calledAt`	When the call ran.	2026-10-30T16:17:22.922Z

The result object is different for each tool. In CSV and Excel it is flattened into columns such as result/currency or result/products/0/title, so for spreadsheets it is often easier to run one tool per batch, or use our dedicated Shopify Products scraper for whole catalogs.

Export tool results to CSV, Excel or Google Sheets

Every run saves its rows to a dataset, and a dataset can be downloaded in any common format. You do not need to write code for this.

From Apify Console. Open the run, go to the Output tab and click Export. Pick CSV, Excel (XLSX), JSON, XML, HTML or RSS. You can tick only the columns you want, for example tool, ok, error, calledAt, result. Nested values such as lists are flattened into columns like result/products/0/title in CSV and Excel.

From a URL. The same export is a plain HTTPS link. Replace <DATASET_ID> with the dataset ID shown on the run's Storage tab:

## CSV with just the columns you need
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&clean=1&fields=tool,ok,error,calledAt,result" -o shopify-mcp-results.csv

## Excel
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=xlsx&clean=1" -o shopify-mcp-results.xlsx

Into Google Sheets. You have three good options:

One-off: download the CSV and use File > Import > Upload in Google Sheets. Choose "Replace current sheet" to refresh an existing tab.
Automatic, no code: in Make, Zapier or n8n, use the Apify app's "Watch Actor runs" (or "Run Actor") trigger, then "Get dataset items", then the Google Sheets "Add row" action. Every scheduled run then lands in your sheet. Apify's own Google Sheets Import & Export Actor can also append a dataset to a sheet, and you can chain it to this Actor's runs with an integration.
Formula: =IMPORTDATA("https://api.apify.com/v2/actor-tasks/<USERNAME>~<TASK_NAME>/runs/last/dataset/items?status=SUCCEEDED&format=csv&token=<YOUR_TOKEN>") always pulls the latest successful run of a saved task. The token sits in the formula, so anyone who can open the sheet can see it. Only use this in a private sheet.

Schedule it to run every Monday at 9 AM

Agents call the server on demand, so most people never schedule it. A batch run on a schedule is useful for small recurring checks, for example a weekly shopify_detect_store on a list of prospects to see who changed theme or added an app.

In the Actor's input form, set up the input from Step 1 and click Save as new task. Give it a clear name such as shopify-mcp-weekly.
Go to Schedules > Create new, set the cron expression to 0 9 * * 1 and pick your timezone, so it runs every Monday at 9 AM.
Add the task to the schedule and save. Each run gets its own fresh dataset.
Optional: on the task's Integrations tab, add a webhook, Slack or email notification for "Run succeeded", or connect Make, Zapier or n8n, so the new rows go where you need them.

To fetch the newest results without looking up a run ID, use the task's last-run link: https://api.apify.com/v2/actor-tasks/<USERNAME>~shopify-mcp-weekly/runs/last/dataset/items?status=SUCCEEDED&format=json.

Call it from the API (Python, JavaScript or curl)

You can start the Actor from your own code with the official Apify clients. Put your API token (Console > Settings > API & Integrations) in an environment variable called APIFY_TOKEN rather than in the code.

Python (pip install "apify-client>=3"). Tested with apify-client 3.4:

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run_input = {
    "calls": [
        {
            "tool": "shopify_detect_store",
            "arguments": {
                "url": "allbirds.com"
            }
        },
        {
            "tool": "shopify_search_products",
            "arguments": {
                "store": "allbirds.com",
                "query": "runner",
                "limit": 3
            }
        },
        {
            "tool": "shopify_app_info",
            "arguments": {
                "app": "judgeme"
            }
        }
    ]
}

run = client.actor("mrslm_data/shopify-data-mcp-server").call(run_input=run_input)

## apify-client 3.x returns a Run object, so use run.default_dataset_id
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["tool"], item["ok"])

In apify-client 3.x, call() returns a typed object. Older examples that use run["defaultDatasetId"] were written for 1.x and 2.x and fail in 3.x with TypeError: 'Run' object is not subscriptable.

JavaScript / Node.js (npm install apify-client):

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
    "calls": [
        {
            "tool": "shopify_detect_store",
            "arguments": {
                "url": "allbirds.com"
            }
        },
        {
            "tool": "shopify_search_products",
            "arguments": {
                "store": "allbirds.com",
                "query": "runner",
                "limit": 3
            }
        },
        {
            "tool": "shopify_app_info",
            "arguments": {
                "app": "judgeme"
            }
        }
    ]
};

const run = await client.actor('mrslm_data/shopify-data-mcp-server').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]);

curl, one request that runs the Actor and returns the rows as CSV (it waits up to 5 minutes, so keep the input small):

curl -X POST "https://api.apify.com/v2/acts/mrslm_data~shopify-data-mcp-server/run-sync-get-dataset-items?format=csv" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"calls": [{"tool": "shopify_detect_store", "arguments": {"url": "allbirds.com"}}, {"tool": "shopify_search_products", "arguments": {"store": "allbirds.com", "query": "runner", "limit": 3}}, {"tool": "shopify_app_info", "arguments": {"app": "judgeme"}}]}' -o shopify-mcp-results.csv

What it costs

The Actor uses pay-per-event pricing. Tool call: $5.00 per 1,000 on the Free and Bronze tiers, $4.50 on Silver and $4.00 on Gold. Each run also has a start fee of $0.00005 per GB of memory (one event at the default memory). For normal batch runs like the one above, the event prices are the whole bill. When an agent uses the Standby MCP URL, Apify also bills the platform usage of the Standby container to your account, in addition to the tool-call events. The container uses 1 GB of memory and stays up for 5 minutes after the last request, so a short agent session adds roughly 0.08 compute units (about $0.02 on the Free plan's $0.20 per unit) on top of the calls.

Price per event

Current pay-per-event prices for this Actor on Apify, by Apify subscription plan:

Event (per 1,000)	Free / Bronze	Silver	Gold / Platinum / Diamond
Tool call (`tool-call`)	$5.00	$4.50	$4.00
Actor start (once per run at the default memory, not per 1,000)	$0.00005	$0.00005	$0.00005

You are charged only for the events in this table: nothing for compute, and nothing for searches that return no rows beyond the start fee.

Scenario	Free / Bronze	Silver	Gold
The run in this guide (3 tool calls)	$0.015	$0.0135	$0.012
An agent session with 20 tool calls (batch price only)	$0.10	$0.09	$0.08
200 tool calls in a month	$1.00	$0.90	$0.80
1,000 tool calls in a month	$5.00	$4.50	$4.00

To cap spending, set Maximum cost per run in the run options (or maxTotalChargeUsd in the API). The Actor stops cleanly at the cap and you are never billed past it. Failed calls (store not found, not a Shopify store, blocked by robots.txt) are not charged.

Limits

Public data only: no orders, customers, inventory counts or anything behind a store login.
The store tools need a Shopify store with its public catalog JSON enabled; a few stores turn it off or block automated requests.
shopify_search_products returns at most 100 products per call. For full catalogs use the Shopify Products scraper.
shopify_app_info returns listing data, not individual reviews. For reviews use our Shopify App Reviews scraper.
A batch run takes up to 50 calls.
Standby usage is billed by Apify on top of the events, as explained above.

FAQ

Do I need a Shopify API key or access to the store? No. The tools read what the store publishes to every visitor. You only need your Apify token.

Which MCP clients work? Any client that supports remote MCP over Streamable HTTP with a custom Authorization header, such as Cursor, VS Code and most agent frameworks.

Does it work on stores that are not Shopify? product_page_extract works on most product pages on any platform, and shopify_detect_store tells you which platform a site uses. The other store tools need Shopify; on other sites the call fails and is not charged.

Can I use it without an AI agent? Yes. Start a normal run with a tool and its arguments, or a list of calls, and read the dataset.

Can I run it on a schedule? Yes. Save your input as a task and attach a schedule, as shown above. Each run is independent and returns the tool results available at that moment.

Does it work with Make, Zapier or n8n? Yes. All three have an Apify app. Use "Run Actor" (or run a saved task), then "Get dataset items" to pass the rows to the next step, such as Google Sheets, Airtable, a CRM or Slack.

Is it legal?

This Actor only reads pages and feeds that the website itself publishes to every visitor without a login. It obeys each site's robots.txt, keeps a polite request rate, and never tries to get past logins, paywalls, captchas or bot checks. It does not collect personal data such as emails, phone numbers or names of private individuals. You are responsible for how you use the data: follow the source site's terms, copyright and the privacy laws that apply to you (GDPR, CCPA, etc.). This tool is independent and not affiliated with or endorsed by the platforms it reads.

Actor input Schema

`tool` (type: `string`):

Tool to run in a normal (batch) run.

`arguments` (type: `object`):

Arguments for the tool as JSON, e.g. {"store": "allbirds.com", "query": "runner", "limit": 5}. See the README for each tool's arguments.

`calls` (type: `array`):

Run up to 50 tool calls in one run: [{"tool": "shopify_app_info", "arguments": {"app": "judgeme"}}, ...].

Actor input object example

{
  "tool": "shopify_search_products",
  "arguments": {
    "store": "allbirds.com",
    "query": "runner",
    "limit": 5
  }
}

Actor output Schema

`results` (type: `string`):

All results as a dataset (JSON, CSV, Excel and more via the API or Console).

`summary` (type: `string`):

Counts of results, targets that succeeded or failed, and the stop reason.

API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

JavaScript example

import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "tool": "shopify_search_products",
    "arguments": {
        "store": "allbirds.com",
        "query": "runner",
        "limit": 5
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrslm_data/shopify-data-mcp-server").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

Python example

from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "tool": "shopify_search_products",
    "arguments": {
        "store": "allbirds.com",
        "query": "runner",
        "limit": 5,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("mrslm_data/shopify-data-mcp-server").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

CLI example

echo '{
  "tool": "shopify_search_products",
  "arguments": {
    "store": "allbirds.com",
    "query": "runner",
    "limit": 5
  }
}' |
apify call mrslm_data/shopify-data-mcp-server --silent --output-dataset

MCP server setup

{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrslm_data/shopify-data-mcp-server"
        }
    }
}

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an Authorization: Bearer <APIFY_API_TOKEN> header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/k9zg9adIVYHs6g3zz/builds/XerQcj5XvjCnBHl4J/openapi.json