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

Scrape any Shopify store via the public /products.json endpoint. Get product title, vendor, type, tags, images, full variants (SKU, price, compare-at, availability), and options. No auth, no browser, works on most myshopify.com stores and custom domains.

- **URL**: https://apify.com/thirdwatch/shopify-store-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 61 total users, 6 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.20 / 1,000 results

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

> **Thirdwatch portfolio:** 8,800+ users across 140+ public Actors, 2M+ records delivered, >95% run success. [Explore all Thirdwatch Actors](https://apify.com/thirdwatch).

> Scrape products from any Shopify store: title, vendor, tags, images, prices, compare-at prices, and full variant data.

### What you get

Structured product data for **any public Shopify storefront** — no login, no API key, no merchant permission needed. Pass one or more store URLs (homepages, `myshopify.com` subdomains, or specific collection URLs) and get back every product with variants, images, prices, tags, and inventory status. Ideal for competitive intelligence, price monitoring, DTC market research, and product-catalog mirroring.

### Output fields

| Field | Description |
|-------|-------------|
| `store_domain` | Store domain (e.g., `allbirds.com`) |
| `store_url` | Original store URL provided |
| `url` | Product page URL |
| `product_id` | Shopify product ID |
| `handle` | URL handle / slug |
| `title` | Product title |
| `vendor` | Brand / vendor name |
| `product_type` | Category (e.g., "Shoes", "Apparel") |
| `tags` | Array of tags applied by the merchant |
| `description` | Product description |
| `image` | Main product image URL |
| `images` | All product image URLs |
| `options` | Variant options (Size, Color, etc.) |
| `min_price` | Lowest variant price |
| `max_price` | Highest variant price |
| `min_compare_at_price` | Lowest compare-at (pre-discount) price |
| `max_compare_at_price` | Highest compare-at price |
| `on_sale` | True if any variant is discounted |
| `variants` | Array of `{id, title, sku, price, compare_at_price, available, option1/2/3}` |
| `variant_count` | Number of variants |
| `available` | True if any variant is in stock |
| `created_at` | Product creation date |
| `updated_at` | Last update date |
| `published_at` | Publish date to storefront |

### Example output

```json
{
    "store_domain": "allbirds.com",
    "store_url": "https://www.allbirds.com",
    "url": "https://www.allbirds.com/products/mens-wool-runners",
    "product_id": 4029431775334,
    "handle": "mens-wool-runners",
    "title": "Men's Wool Runners",
    "vendor": "Allbirds",
    "product_type": "Shoes",
    "tags": ["mens", "runner", "wool"],
    "description": "Our iconic everyday shoe, spun from superfine merino wool...",
    "image": "https://cdn.shopify.com/...",
    "images": ["https://cdn.shopify.com/...", "https://cdn.shopify.com/..."],
    "options": ["Size", "Color"],
    "min_price": 110.0,
    "max_price": 110.0,
    "on_sale": false,
    "variants": [
        {"id": 39274, "title": "10 / Natural Grey", "sku": "WR-NG-10", "price": 110.0, "available": true}
    ],
    "variant_count": 24,
    "available": true,
    "created_at": "2021-05-12T10:00:00Z",
    "updated_at": "2026-04-10T08:32:11Z",
    "published_at": "2021-05-12T10:05:00Z"
}
```

### Input parameters

| Parameter | Required | Description |
|-----------|----------|-------------|
| `storeUrls` | Yes | List of Shopify store URLs. Accepts homepages, myshopify subdomains, or collection URLs. |
| `maxProductsPerStore` | No | Maximum products per store. Default `25`. Raise for full-catalog pulls. |
| `includeVariants` | No | Include full variant list per product. Default `true`. Disable for smaller output. |
| `useProxy` | No | Route through Apify's proxy. Default `false`. Enable only if a store returns errors. |

### Use cases

- **DTC brands & marketers**: Track competitor launches, prices, and sale events across a list of Shopify rivals.
- **Price monitoring tools**: Mirror pricing & availability across target stores for alert systems.
- **Dropshippers & affiliates**: Pull catalogs into a mirror database with variant-level inventory.
- **Investors & analysts**: Measure catalog size, price bands, and sale cadence across a portfolio of DTC brands.

### Limitations

- Works on **public Shopify storefronts only**. Private stores, password-locked stores, and stores that disable public catalog access are not supported (the store is skipped and no charge applies).
- Currency is not published in the product feed. Prices are floats in the store's default currency — handle conversions downstream.
- Individual product reviews are NOT included. Use the [Shopify Reviews Scraper](https://apify.com/thirdwatch/shopify-reviews-scraper?fpr=9m2cd6) for aggregate review data.

### Compared to alternatives

- **vs. other Apify Store Shopify scrapers** (typically $0.005-$0.01 per product): this actor costs less per product with the same fields.
- **vs. manual CSV exports**: requires being the store owner or a partner. This actor works on any public Shopify storefront without permissions.

Pairs well with the [Shopify Reviews Scraper](https://apify.com/thirdwatch/shopify-reviews-scraper?fpr=9m2cd6) for review counts and ratings.

### FAQ

**Do I need to own the store?**
No. Any publicly visible Shopify storefront works.

**What about custom domains?**
Fully supported. Pass the brand's primary domain (e.g., `allbirds.com` or `gymshark.com`).

**Can I pull a specific collection only?**
Yes. Pass the collection URL (e.g., `https://shop.gymshark.com/collections/mens-new-releases`) and only products in that collection are scraped.

**Will this work on Shopify Plus stores?**
Yes.

Last verified: 2026-04

More scrapers at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

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

List of Shopify store URLs to scrape. Accepts the homepage (e.g. 'https://www.allbirds.com'), a myshopify.com subdomain, or a specific collection URL (e.g. 'https://store.com/collections/new-arrivals').

## `collectionHandles` (type: `array`):

Optional list of Shopify collection handles (e.g. 'mens-shoes', 'sale', 'new-arrivals'). When provided, each store URL is scraped once per handle via /collections/{handle}/products.json. Collections are Shopify's per-store category equivalent -- there is no global taxonomy across stores. Leave empty to scrape the store's full catalog from /products.json.

## `sortBy` (type: `string`):

Sort order for collection results. Note: Shopify's root /products.json (no collection) DOES NOT support sort_by -- sorting only applies to collection URLs. For root /products.json, this field is ignored and Shopify's natural pagination order is used.

## `minPrice` (type: `integer`):

Optional minimum price filter. Applied as a POST-filter in code (Shopify's /products.json does not accept price params). A product is kept if any of its variants has a price >= minPrice.

## `maxPrice` (type: `integer`):

Optional maximum price filter. Applied as a POST-filter in code. A product is kept if any of its variants has a price <= maxPrice.

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

Maximum number of products to fetch per store. Start small for a test run; raise for full catalog pulls.

## `includeVariants` (type: `boolean`):

If true, include the full list of variants (size/color/SKU/price/availability) on each product. If false, only the price range is kept (smaller output).

## `useProxy` (type: `boolean`):

Route requests through Apify's proxy. Most Shopify stores work without it; enable this only if a specific store returns errors.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.allbirds.com"
  ],
  "collectionHandles": [],
  "sortBy": "relevance",
  "maxProductsPerStore": 25,
  "includeVariants": true,
  "useProxy": 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"
    ],
    "collectionHandles": [],
    "maxProductsPerStore": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/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"],
    "collectionHandles": [],
    "maxProductsPerStore": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/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": [
    "https://www.allbirds.com"
  ],
  "collectionHandles": [],
  "maxProductsPerStore": 25
}' |
apify call thirdwatch/shopify-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thirdwatch/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/sUzFmCo44ZO0aX73W/builds/2ZX0DyP1wK0BNGnfj/openapi.json