# 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](https://apify.com/mrslm_data) (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](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`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

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

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

2. 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.
3. Download the results as JSON, CSV or Excel from the **Output** tab, or schedule the run to repeat.

### Tools

| Tool | What it returns |
|---|---|
| `shopify_search_products` | Products of any Shopify store, with optional text filter, collection and on-sale filter: title, vendor, type, price range, sale and stock flags |
| `shopify_get_product` | One product with every variant (SKU, price, compare-at price, availability) |
| `shopify_list_collections` | A store's collections with product counts |
| `shopify_detect_store` | Is it Shopify? Theme, currency, country, detected apps and tools |
| `shopify_app_info` | Shopify App Store listing: developer, rating, review count, pricing plans, categories, languages, integrations (no individual reviews or reviewer names) |
| `product_page_extract` | Name, brand, SKU/GTIN, price, stock and rating from any product page on any platform |

### Sample tool result (real run, trimmed)

```json
{
  "handle": "judgeme",
  "name": "Judge.me Product Reviews App",
  "developer": "Judge.me",
  "rating": 5,
  "reviewCount": 49107,
  "categories": ["Product reviews", "SEO"],
  "hasFreePlan": true,
  "pricingPlans": [{"name": "Forever Free", "price": "Free"}, {"name": "Awesome", "price": "$15 / month"}],
  "launched": "June 25, 2015"
}
```

### Connect your agent

The server runs in Apify Standby mode. Add it to any MCP client that supports Streamable HTTP:

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

Put your own Apify API token (Console > Settings > API & Integrations) in place of `<YOUR_APIFY_TOKEN>`. The same URL is shown on the Actor's **Standby** tab.

### Run tools without an agent

Start a normal run, pick a **Tool** and its **Tool arguments** (or list several in **Several tool calls**). Each call becomes one dataset row with its result.

### Who uses this

- **AI shopping and research agents**: answer "what does this store sell and for how much?" with live data.
- **E-commerce analysts**: ask an assistant to compare competitors' catalogs, prices and tech stacks.
- **Shopify app makers**: let an agent look up rival apps' ratings and pricing plans.

### Pricing

**$0.005 per successful tool call** (Silver $0.0045, Gold $0.004) + $0.00005 per run. Failed calls (store not found, not Shopify, blocked by robots.txt) are free. Each call makes a few polite requests to public pages only.

### FAQ

**Do I need a Shopify API key or store access?** No. The tools read only what every Shopify store publishes to visitors (public catalog JSON and pages). You only need your Apify token.

**Which MCP clients work?** Any client that supports remote MCP over Streamable HTTP, such as Claude Desktop (via a remote connector), Cursor, VS Code and agent frameworks with MCP support.

**What does a typical agent session cost?** About $0.005 per successful tool call, so 200 calls cost about $1. Failed calls are free.

**Can I use it without an AI agent?** Yes. Start a normal run with a tool and its arguments (see the Quick start), and each call becomes a dataset row.

**Does it work on non-Shopify stores?** `product_page_extract` works on most product pages on any platform. `shopify_app_info` reads the Shopify App Store. The store tools need a Shopify store; on other sites the call fails and is not charged.

### 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

```json
{
  "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

```javascript
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

```python
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

```bash
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

```json
{
    "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/p4RnE3lwq2Kbhi0st/openapi.json