# Shopify Store Scraper — Products, Prices & Variants (`flash_scraper/shopify-store-scraper`) Actor

Export any Shopify store's full product catalog (titles, prices, SKUs, variants, images) to JSON/CSV via the store's public product feed.

- **URL**: https://apify.com/flash\_scraper/shopify-store-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.35 / actor start

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Shopify Store Product Scraper — export any store's catalog to CSV, Excel or JSON

**A Shopify store product scraper that pulls a store's entire public catalog in one run** — titles, vendors, prices, variants, SKUs, availability, tags and images — with no login, no browser automation, and no code. Paste one or more store URLs and export Shopify products to CSV, Excel or JSON minutes later. If you monitor competitors, research dropshipping niches, or track prices across Shopify stores, this replaces hours of copy-paste with a single input field.

### What it does

- **Reads each store's public `/products.json` feed** — the same product data Shopify serves to any visitor, fetched over plain HTTP.
- **Paginates the full catalog automatically** — 250 products per request, page after page, until the store runs out (with a hard safety cap of 1,000 pages ≈ 250k products per store).
- **Two output shapes** — one row per product with a summarized price range (`price_min` / `price_max`, `in_stock`, `variants_count`), or one row per variant with per-variant `sku`, `price`, `compare_at_price`, `available` and `grams` — ideal for price and stock monitoring.
- **Handles many stores in one run** — pass a list of competitor URLs; a store that fails (password-protected, feed disabled, not actually Shopify) is logged and skipped, and the run continues.
- **Normalizes messy input** — `allbirds.com`, `www.allbirds.com` or a full product URL all resolve to the correct store base.
- **Optional per-store cap** — limit each store to the first N products, or take everything with `0`.

### Use cases

- **E-commerce competitor monitoring** — schedule a daily run over your competitors' stores and diff prices, new products, and stock status over time.
- **Dropshipping research** — pull a winning store's full catalog with vendors, tags and product types to spot trending products and suppliers.
- **Price tracking** — use variant mode to get one row per SKU with `price` and `compare_at_price`, then feed the dataset into a sheet or dashboard.
- **Catalog migration and backup** — export a store's product list without private API keys or admin access.
- **Market analysis** — scrape every store in a niche and aggregate by `product_type`, `vendor`, or price band.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `storeUrls` | array | — (required) | One or more Shopify store URLs (e.g. `https://www.allbirds.com`). The scraper reads each store's public `/products.json` feed. |
| `maxProducts` | integer | `0` | Limit how many products to fetch per store. Use `0` for no limit (entire catalog). |
| `oneRowPerVariant` | boolean | `false` | ON: emit a row for every variant (best for price/SKU monitoring). OFF: one row per product with a price range. |

```json
{
  "storeUrls": ["https://www.allbirds.com"],
  "maxProducts": 0,
  "oneRowPerVariant": false
}
````

### Output

Every row carries the core product record: `store`, `product_id`, `title`, `handle`, `url`, `vendor`, `product_type`, `tags`, first `image` URL, `images_count`, and the Shopify `created_at` / `published_at` / `updated_at` timestamps.

- With **one row per product** (default), each row adds `variants_count`, `price_min`, `price_max`, and `in_stock`.
- With **one row per variant**, each row adds `variant_id`, `variant_title`, `sku`, `price`, `compare_at_price`, `available`, and `grams` instead.

Example row (default product mode):

```json
{
  "store": "https://www.allbirds.com",
  "product_id": 4547069443119,
  "title": "Men's Wool Runners",
  "handle": "mens-wool-runners",
  "url": "https://www.allbirds.com/products/mens-wool-runners",
  "vendor": "Allbirds",
  "product_type": "Shoes",
  "tags": "mens, wool, runners",
  "image": "https://cdn.shopify.com/s/files/1/1104/4168/products/wool-runner.jpg",
  "images_count": 6,
  "created_at": "2020-03-18T09:12:44-07:00",
  "published_at": "2020-03-20T08:00:01-07:00",
  "updated_at": "2026-06-28T02:14:09-07:00",
  "variants_count": 14,
  "price_min": 110.0,
  "price_max": 125.0,
  "in_stock": true
}
```

Export the dataset as **CSV, Excel, JSON, or HTML** from the run's Dataset tab, or pull it programmatically via the Apify API — both output shapes are flat, so CSV export needs no post-processing.

#### Example output

A real sample from a live run:

| title | vendor | product\_type | price\_min | price\_max | in\_stock |
|---|---|---|---|---|---|
| Men's Cruiser Terralux - Anthracite (Da… | Allbirds | Shoes | 135 | 135 | false |
| Women's Wool Runner NZ Mid Waterproof -… | Allbirds | Shoes | 160 | 160 | true |
| Free Returns Coverage | re:do | return,package\_protection | 0.8 | 2.98 | true |
| Women's Wool Runner-up Mizzle - Hazy In… | Allbirds | Shoes | 60 | 60 | true |

### Pricing

This actor uses **Apify pay-per-event pricing charged per `result`** — you pay only for the product (or variant) rows actually delivered to your dataset. No subscription, and a run that returns nothing costs nothing. See the actor's Pricing tab for the current per-result rate. A **free Apify plan is enough to try it** on a full mid-size store.

Tip: variant mode produces more rows than product mode for the same store (one per SKU), so pick the shape that matches what you actually need.

### Tips / FAQ

**Is this legal?**
It reads each store's own **public** `/products.json` feed — data Shopify serves to any anonymous visitor. No login, no private data, no paywall bypass. As always, use scraped data responsibly and within applicable laws and the store's terms.

**Does it work on every Shopify store?**
Most standard stores, yes. Password-protected storefronts and stores that have disabled the public product feed return an error for `/products.json`; those stores are logged with a warning and **skipped**, and the rest of the run continues. Non-Shopify URLs are skipped the same way.

**Does it include product descriptions?**
No — rows include title, vendor, type, tags, timestamps, image URL and price/variant data, but not the HTML description body. If you need descriptions, pair it with an extraction actor on the product URLs (see Related actors below).

**How do I track prices over time?**
Turn `oneRowPerVariant` ON so every SKU gets its own row with `price` and `compare_at_price`, then schedule the actor (Apify Schedules) and compare datasets between runs.

**How fast is it, and are there limits?**
It fetches 250 products per request, so even multi-thousand-product catalogs finish in minutes. A built-in cap of 1,000 pages per store (≈ 250,000 products) guards against runaway loops; `maxProducts` lets you set your own tighter cap.

**Do I need proxies or an API key?**
No. The feed is public and the actor uses plain HTTP requests — no Shopify API key, no login, no headless browser.

### Related actors

- [Shopify Leads Scraper](https://apify.com/flash_scraper/shopify-leads-scraper) — find Shopify **stores** (with contact data) instead of products; the natural front end to this actor.
- [Smart Scraper by Example](https://apify.com/flash_scraper/smart-scraper-by-example) — extract extra fields (like descriptions) from the product URLs this actor gives you.
- [Company & Domain Enricher](https://apify.com/flash_scraper/company-domain-enricher) — turn store domains into full company records with tech stack and socials.

***

Found a bug or need a feature? Open an Issue on this actor's **Issues** tab — typical response within 1 business day.

# Actor input Schema

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

One or more Shopify store URLs (e.g. https://www.allbirds.com). The scraper reads each store's public /products.json feed.

## `maxProducts` (type: `integer`):

Limit how many products to fetch per store. Use 0 for no limit (entire catalog).

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

ON: emit a row for every variant (best for price/SKU monitoring). OFF: one row per product with a price range.

## Actor input object example

```json
{
  "storeUrls": [
    "https://store.example.com"
  ],
  "maxProducts": 0,
  "oneRowPerVariant": false
}
```

# Actor output Schema

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

No description

# 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": [
        "https://www.allbirds.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/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": ["https://www.allbirds.com"] }

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/shopify-store-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "https://www.allbirds.com"
  ]
}' |
apify call flash_scraper/shopify-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=flash_scraper/shopify-store-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Scraper — Products, Prices & Variants",
        "description": "Export any Shopify store's full product catalog (titles, prices, SKUs, variants, images) to JSON/CSV via the store's public product feed.",
        "version": "0.1",
        "x-build-id": "knO8WlWlbOSKvLyx7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flash_scraper~shopify-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flash_scraper-shopify-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/flash_scraper~shopify-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-flash_scraper-shopify-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/flash_scraper~shopify-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-flash_scraper-shopify-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "Shopify store URLs",
                        "type": "array",
                        "description": "One or more Shopify store URLs (e.g. https://www.allbirds.com). The scraper reads each store's public /products.json feed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Max products per store",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Limit how many products to fetch per store. Use 0 for no limit (entire catalog).",
                        "default": 0
                    },
                    "oneRowPerVariant": {
                        "title": "One row per variant",
                        "type": "boolean",
                        "description": "ON: emit a row for every variant (best for price/SKU monitoring). OFF: one row per product with a price range.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```