# Shopify Store Scraper - Products, Prices, Stock & Store Leads (`get_anything/shopify-store-scraper`) Actor

Scrape any Shopify store: full product catalog with prices, discounts, variants, SKUs and stock, plus store profile (location, currency, theme, apps, emails, socials). Monitor mode returns only new products, price drops and stock changes. No API key.

- **URL**: https://apify.com/get_anything/shopify-store-scraper.md
- **Developed by:** [Get Anything](https://apify.com/get_anything) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Store Scraper - Products, Prices, Stock & Store Leads

Scrape **any public Shopify store** in seconds: the full product catalog with prices, compare-at prices, discounts, variants, SKUs and stock, plus a **store profile** for lead lists (location, currency, product count, ships-to countries, theme, detected apps, public emails and social links).

Turn on **Monitor mode** and schedule it: each run returns only what changed (new products, price drops, sales starting or ending, back-in-stock, out-of-stock and removed products).

No API key, no login, no browser. Fast and cheap.

### What you can do with it

- **Competitor price monitoring:** track a rival's prices, discounts and stock every day.
- **Product research and dropshipping:** pull whole catalogs, vendors, product types and tags.
- **Shopify store leads:** check a list of domains and get the store profile, the apps it uses (Klaviyo, Judge.me, Recharge, Gorgias, Attentive...), emails and socials. Useful for agencies and Shopify app vendors.
- **Back-in-stock and sale alerts:** combine Monitor mode with a schedule and a webhook, Slack, email or Make/Zapier.
- **AI agents (ChatGPT, Claude, Cursor via Apify MCP):** "What's on sale at colourpop.com right now?" Results are compact by default.

### Input

| Field | Description |
|---|---|
| `storeUrls` | Domains or URLs. Accepts `allbirds.com`, a store URL, a **collection URL** (`/collections/sale`) or a **product URL** (`/products/handle`). |
| `maxProductsPerStore` | Cap per store (default 100). `0` = whole catalog. |
| `includeProducts` | Scrape products (default on). |
| `includeStoreProfile` | Add one store/lead row per store (default on). |
| `onlyChanges` | Monitor mode: only changes since the last run. |
| `includeDescription` | Add product descriptions as plain text (default off). |
| `oneRowPerVariant` | One row per size/colour variant instead of a nested list. |

Example:

```json
{
  "storeUrls": ["allbirds.com", "https://colourpop.com/collections/lips"],
  "maxProductsPerStore": 50,
  "onlyChanges": false
}
```

### Output

**Product row**

```json
{
  "resultType": "product",
  "store": "allbirds.com",
  "storeName": "Allbirds",
  "title": "Men's Tree Runner - Jet Black (White Sole)",
  "url": "https://allbirds.com/products/mens-tree-runners",
  "vendor": "Allbirds",
  "productType": "Shoes",
  "price": 100.0,
  "compareAtPrice": null,
  "onSale": false,
  "discountPercent": null,
  "currency": "USD",
  "available": true,
  "variantsCount": 12,
  "variantsAvailable": 9,
  "variants": [{ "title": "8", "sku": "TR3MJBW080", "price": 100.0, "available": true }],
  "image": "https://cdn.shopify.com/...",
  "publishedAt": "2025-03-01T10:00:00-08:00"
}
```

In Monitor mode each row also has `changeTypes` (`new`, `price_drop`, `price_increase`, `sale_started`, `sale_ended`, `back_in_stock`, `out_of_stock`, `removed`), plus `previousPrice` and `previousAvailable`.

**Store profile row**

```json
{
  "resultType": "store",
  "store": "colourpop.com",
  "name": "ColourPop",
  "city": "Oxnard",
  "country": "US",
  "currency": "USD",
  "productsCount": 1063,
  "shipsToCountriesCount": 180,
  "theme": { "name": "Colourpop/Main", "schemaName": "Colourpop" },
  "apps": ["Klaviyo", "Yotpo", "Okendo", "Gorgias", "Attentive", "Klarna"],
  "emails": [],
  "socials": { "instagram": "https://instagram.com/colourpopcosmetics", "tiktok": "https://www.tiktok.com/@colourpopco" }
}
```

Domains that aren't Shopify stores, or whose catalog is disabled, return a free `error` row, so you can also use this to check which domains run Shopify.

### How Monitor mode works

The Actor saves a snapshot per store (or per collection) in a named key-value store, `shopify-store-monitor`. The first run returns every product as `new`. Later runs return only the differences. Removed products are detected when the whole catalog or collection was fetched (`maxProductsPerStore: 0`, or fewer products than the cap). Schedule it daily in Apify Schedules and connect a webhook or integration for alerts.

### Use it from ChatGPT, Claude & AI agents

This Actor works as a tool for AI assistants through the **Apify MCP server**, and the inputs are designed so an agent can fill them in.

- **Claude (claude.ai / Desktop), ChatGPT, Cursor, VS Code, Windsurf:** add the MCP server URL below as a custom connector / MCP server and sign in with your Apify account:

  ```
  https://mcp.apify.com/?tools=get_anything/shopify-store-scraper
  ```

- **Claude Desktop / Cursor config file:**

  ```json
  { "mcpServers": { "apify": { "url": "https://mcp.apify.com/?tools=get_anything/shopify-store-scraper" } } }
  ```

- **Any LLM framework or GPT Action (REST):** one call runs the Actor and returns the results as JSON:

  ```
  POST https://api.apify.com/v2/acts/get_anything~shopify-store-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN
  ```

- **No-code:** Make, Zapier, n8n, LangChain and LlamaIndex have Apify integrations.

Then just ask, for example: *"What's on sale at allbirds.com right now, and which apps does the store use?"*

### Pricing

Pay per event: you pay per product row and per store profile. Non-Shopify domains are free. See the Pricing tab for current prices.

### FAQ

**Does it work on every Shopify store?** It works on any store that serves the standard public `/products.json` feed, which is almost all of them. A few stores disable it, and you'll get a clear error row.

**Do I need a proxy?** Usually not. For very large or frequent runs you can enable Apify Proxy.

**Is it legal?** It reads only public storefront data that Shopify serves to every visitor. Don't use it to collect personal data beyond public business contacts, and follow the store's terms.

# Actor input Schema

## `storeUrls` (type: `array`):

Shopify stores to scrape. Accepts a domain ('allbirds.com'), a store URL, a collection URL ('https://store.com/collections/sale') or a product URL ('https://store.com/products/handle').

## `maxProductsPerStore` (type: `integer`):

Cap on products per store. 0 = the whole catalog.

## `includeProducts` (type: `boolean`):

Scrape the product catalog (prices, discounts, variants, SKUs, stock).

## `includeStoreProfile` (type: `boolean`):

Add one store row: name, city/country, currency, product and collection counts, ships-to countries, theme, detected apps (Klaviyo, Judge.me, Recharge...), public emails and social links.

## `onlyChanges` (type: `boolean`):

Keep a snapshot per store and return only new products, price drops/increases, sale start/end, back-in-stock/out-of-stock and removed products. The first run returns every product as 'new'. Schedule it daily for price and stock monitoring.

## `includeDescription` (type: `boolean`):

Add the product description as plain text. Off by default to keep results compact for AI agents.

## `oneRowPerVariant` (type: `boolean`):

Output one row per variant (size/colour) instead of one row per product with a variants list. Handy for spreadsheets.

## `proxyConfiguration` (type: `object`):

Optional. Shopify's public endpoints usually work without a proxy.

## Actor input object example

```json
{
  "storeUrls": [
    "allbirds.com",
    "colourpop.com"
  ],
  "maxProductsPerStore": 20,
  "includeProducts": true,
  "includeStoreProfile": true,
  "onlyChanges": false,
  "includeDescription": false,
  "oneRowPerVariant": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Structured results in the default dataset - one item per product (or variant) and one per store profile.

# 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 = {
    "storeUrls": [
        "allbirds.com",
        "colourpop.com"
    ],
    "maxProductsPerStore": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("get_anything/shopify-store-scraper").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 = {
    "storeUrls": [
        "allbirds.com",
        "colourpop.com",
    ],
    "maxProductsPerStore": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("get_anything/shopify-store-scraper").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 '{
  "storeUrls": [
    "allbirds.com",
    "colourpop.com"
  ],
  "maxProductsPerStore": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call get_anything/shopify-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,get_anything/shopify-store-scraper"
        }
    }
}
```

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/eililHggY8tUIMhdN/builds/h9iaSXYBhcvcgREL8/openapi.json