# Shopify & WooCommerce Store Products Scraper (`subimpact/shopify-store-products`) Actor

Export any Shopify or WooCommerce store catalogue as JSON: products, variants, prices, compare-at prices, stock, tags and images. Auto-detects the platform, plain HTTP, residential proxy included. From $0.50 per 1,000 products.

- **URL**: https://apify.com/subimpact/shopify-store-products.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** E-commerce, Developer tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 product scrapeds

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 & WooCommerce Store Products Scraper

Export the whole product catalogue of any Shopify or WooCommerce store as clean JSON — title, price,
compare-at price, currency, stock, tags, images, variants — from the store's own public catalogue JSON.
No browser, no login, no API key.

Paste one store URL or a hundred. The actor detects the platform for each store by itself and reads
whichever public endpoint that platform serves:

| Platform | Endpoint read |
| --- | --- |
| Shopify | `https://<store>/products.json?limit=250&page=N`, `https://<store>/collections/<handle>/products.json` |
| WooCommerce | `https://<store>/wp-json/wc/store/v1/products?per_page=100&page=N` (the public Store API) |

**Pricing: $0.50 per 1,000 products** ($0.0005 per delivered product row). Store error rows and empty
catalogues are free.

### What you get

One dataset row per product: store URL, platform, product id, handle, title, vendor, product type, tags,
product URL, lowest variant price, compare-at price, currency, availability, variant count, the variants
themselves, image URLs, a plain-text description, Shopify created/updated timestamps, scrape timestamp and
a status.

- **Variants**: id, title, SKU, price, compare-at price and stock per variant (`includeVariants`, on by default).
- **Price** is the cheapest variant price — the "from" price a storefront shows — so it always describes
  something you can actually buy. `compareAtPrice` is the compare-at price of that same variant.
- **available** is true when any variant is buyable.
- **description** is HTML-stripped, entity-decoded and capped at 20,000 characters.
- **text fields** (title, vendor, product type, tags, variant titles) are entity-decoded too, so
  `Dropshipfy &#8211; Easy Dropshipping` arrives as `Dropshipfy – Easy Dropshipping`.
- **Currency**: Shopify stores are asked for it once per store (`/meta.json`, falling back to `/cart.js`);
  WooCommerce returns `prices.currency_code` on every product. Unknown currencies are `null`, never guessed.
- Nothing is invented: a missing upstream value (no SKU, no sale price, no image) stays `null`.

### Quick start

Input:

```json
{
  "storeUrls": ["https://www.allbirds.com"],
  "maxProductsPerStore": 250,
  "maxItems": 1000,
  "includeVariants": true
}
```

That is one product request plus a currency lookup: a couple of seconds and $0.125 for 250 products.

#### Scrape only some Shopify collections

```json
{
  "storeUrls": ["https://www.allbirds.com"],
  "collectionHandles": ["mens", "womens-shoes"],
  "maxItems": 500
}
```

`collectionHandles` accepts bare handles (`mens`) or pasted URLs (`https://store.com/collections/mens`); a collection title is converted to its handle (`"Men's Shoes"` -> `mens-shoes`), and the exact handle is the part after `/collections/` in the collection URL.
It is ignored for WooCommerce stores, which are scraped whole. A product that appears in two collections is
delivered once.

#### Scrape a set of stores

```json
{
  "storeUrls": [
    "https://www.allbirds.com",
    "https://woocommerce.com",
    "https://www.advancedcustomfields.com"
  ],
  "maxProductsPerStore": 100,
  "maxItems": 300
}
```

### Output example

A real row from a live run (formatted for readability):

```json
{
  "storeUrl": "https://www.mvmt.com",
  "platform": "shopify",
  "productId": "10221706969336",
  "handle": "odyssey-ii-carnation-gold-25mm-28000352",
  "title": "Odyssey II Carnation Gold 25mm",
  "vendor": "MVMT",
  "productType": "Watches",
  "tags": ["BOGO_50", "BOGO_Y", "Womens", "YGroup_odyssey-ii-25"],
  "url": "https://www.mvmt.com/products/odyssey-ii-carnation-gold-25mm-28000352",
  "price": 153.95,
  "compareAtPrice": 192.95,
  "currency": "USD",
  "available": true,
  "variantCount": 1,
  "variants": [
    {
      "id": "49993854943480",
      "title": "Carnation Gold",
      "sku": "28000352",
      "price": 153.95,
      "compareAtPrice": 192.95,
      "available": true
    }
  ],
  "images": [
    "https://cdn.shopify.com/s/files/1/0834/8654/0024/files/28000352_fr.jpg?v=1784141353",
    "https://cdn.shopify.com/s/files/1/0834/8654/0024/files/28000352_b.jpg?v=1784147241"
  ],
  "description": "A West Coast approach to an iconic 1970's silhouette. Reimagined from the distinct 70’s shape that’s defied the ordinary for decades, the Odyssey II features hand-polished steel contrasts, faceted hour markers that glint in motion, and a sleek profile.",
  "createdAt": "2026-07-15T14:49:09-04:00",
  "updatedAt": "2026-11-15T04:16:38-05:00",
  "scrapedAt": "2026-11-15T09:16:16.257Z",
  "status": "ok",
  "error": null
}
```

A WooCommerce row carries the same fields; `createdAt`/`updatedAt` are `null` because the public Store API
does not publish creation or modification dates, and WooCommerce variations carry their option values
(`title`: `"License Type: Bundling"`) without per-variation prices or stock.

#### Status values

| status | meaning | charged |
| --- | --- | --- |
| `ok` | product row | yes |
| `error` | the store could not be read — invalid URL, or its catalogue endpoint is disabled, blocked or returned something that is not JSON. `error` names the HTTP status of each endpoint tried | no |
| `empty` | the store answered, but published no products (empty catalogue, or a collection handle with no products) | no |

A run never fails because one store in the list is broken: you get a free `error` row for that store and the
other stores are still scraped.

### Input

| Field | Type | Default | Meaning |
| --- | --- | --- | --- |
| `storeUrls` | array | — (required) | Shopify or WooCommerce store URLs. Pasted `/products.json`, `/collections/...` or `/wp-json/...` URLs are reduced to the store root. |
| `collectionHandles` | array | `[]` | Shopify only: scrape just these collections instead of the whole catalogue. |
| `maxProductsPerStore` | integer | `250` | Stop paging a store after this many products. |
| `maxItems` | integer | `1000` | Hard cap on product rows for the whole run (max 100,000). |
| `includeVariants` | boolean | `true` | Add the `variants` array to each row. |
| `proxyConfiguration` | object | Apify residential proxy | Residential proxy is on by default and its cost is included in the price (see rate limits below). |

A run also stops cleanly when the account's paid-event / max-dataset-items limit is reached; rows already
delivered are kept and charged, and the run status message says how many rows were delivered.

### Rate limits and politeness

The actor makes at most **one request per second per store**, sends no cookies and keeps no session, and
honours `HTTP 429 Retry-After` before retrying (two retries, then the store gets a free `error` row instead
of a hammering loop).

Shopify rate-limits its public `products.json` **per client IP**, shared across stores, and answers
`HTTP 429` with `Retry-After` when the budget is exhausted, and datacenter IP ranges are limited almost at once
(measured 2026-11-15 from Apify: 5 of 6 Shopify stores answered 429 or 403 without a proxy or through datacenter
proxy, 5 of 6 answered 200 through residential proxy). The actor therefore uses Apify residential proxy by default,
without a pinned session, so each request leaves from a rotating IP; the proxy cost is included in the price. A few
large brands block storefront JSON altogether (403); those stores get a free error row.

The actor also stays on HTTP/1.1 for these endpoints: measured on 2026-11-15, identical requests over HTTP/2
got `429` where HTTP/1.1 got `200` (Shopify's limiter is sensitive to the HTTP/2 client fingerprint).

### Notes and limits

- Public catalogue data only: password-protected stores, draft/unpublished products and stores that have
  disabled `products.json` / the Store API cannot be scraped. They produce a free `error` row that names both
  endpoints' HTTP status.
- Product ids are delivered as strings so long ids stay exact.
- Prices are in the store's own currency (a Shopify store selling in EUR gives EUR prices). No FX conversion.
- One row per product, not per variant; use `variants` for variant-level data. To get one row per variant,
  expand the array downstream.
- WooCommerce exposes at most 100 products per request and Shopify 250, so very large catalogues take
  `products / page size` requests at one request per second.

### Development

```bash
npm ci && npm test     # offline: node:test against saved fixtures, no network
node test/live.mjs 5   # live smoke run of the real fetch+parse path (not part of npm test)
```

`src/http.js` owns pacing/retries, `src/shopify.js` and `src/woo.js` are the pure parsers, `src/scrape.js`
owns detection and paging, `src/main.js` owns delivery and charging (a row is pushed first, then charged).

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

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

One or more Shopify or WooCommerce stores. Paste the shop URL (https://store.com) — a pasted /products.json, /collections/... or /wp-json/... URL is reduced to the store root automatically. The platform (Shopify or WooCommerce) is detected for you.

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

Optional. Scrape only these Shopify collections, e.g. shoes or mens-jackets, in the order given. A collection title is accepted and converted to its handle (e.g. Men's Shoes -> mens-shoes); the exact handle is the part after /collections/ in the collection URL. Ignored for WooCommerce stores, which are always scraped whole. Leave empty to scrape every product in the store.

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

Stop paging a store once this many products have been delivered from it. Shopify serves 250 products per request and WooCommerce 100, so the default 250 is one request per store.

## `maxItems` (type: `integer`):

Hard cap on product rows for the whole run, across all stores. The run stops cleanly when it is reached (already-delivered rows are kept and charged). Also bounded by the account's max paid dataset items.

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

Add a variants array to every product row (id, title, sku, price, compareAtPrice, available). Turn it off for smaller rows — variantCount is still delivered. WooCommerce's public Store API exposes variation ids and option values but not per-variation prices, so Woo variant price/compareAtPrice/available are null.

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

Apify Proxy is on by default because Shopify rate-limits its public products.json per IP address (HTTP 429 with Retry-After). Rotating proxy IPs keep large multi-store runs clean. Choose 'No proxy' to use the actor's own connection.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.allbirds.com"
  ],
  "maxProductsPerStore": 250,
  "maxItems": 1000,
  "includeVariants": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `storeUrl` (type: `string`):

Store root the row came from

## `platform` (type: `string`):

shopify or woo

## `productId` (type: `string`):

The store's own product id

## `title` (type: `string`):

Product title

## `handle` (type: `string`):

Shopify handle or WooCommerce slug

## `url` (type: `string`):

Product page URL

## `price` (type: `string`):

Lowest variant price in the store's currency

## `compareAtPrice` (type: `string`):

Struck-through price when the product is on sale

## `currency` (type: `string`):

ISO currency code

## `available` (type: `string`):

Any variant buyable

## `variantCount` (type: `string`):

Number of variants

## `variants` (type: `string`):

Variant array: id, title, sku, price, compareAtPrice, available

## `images` (type: `string`):

Product image URLs

## `description` (type: `string`):

Product description, HTML stripped, max 20,000 characters

## `vendor` (type: `string`):

Shopify vendor or WooCommerce brand

## `productType` (type: `string`):

Shopify product type or first WooCommerce category

## `tags` (type: `string`):

Product tags

## `createdAt` (type: `string`):

Shopify created_at (null on WooCommerce)

## `updatedAt` (type: `string`):

Shopify updated_at (null on WooCommerce)

## `scrapedAt` (type: `string`):

Run timestamp

## `status` (type: `string`):

ok, empty or error (empty/error rows are not charged)

## `error` (type: `string`):

Why a row is empty/error

# 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("subimpact/shopify-store-products").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("subimpact/shopify-store-products").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"
  ]
}' |
apify call subimpact/shopify-store-products --silent --output-dataset

```

## MCP server setup

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

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/2hDrjh1JwjWjkLfyR/builds/18VuWnTaiKYxA0iGq/openapi.json
