# Shopify & WooCommerce Product Scraper + Price Monitor (`henri_dewitte/shopify-woocommerce-product-scraper`) Actor

Scrape all products, prices, variants, stock, SKUs and barcodes from any Shopify or WooCommerce shop (plus other shops with schema.org data). Built-in price and stock change tracking. $1 per 1,000 products.

- **URL**: https://apify.com/henri_dewitte/shopify-woocommerce-product-scraper.md
- **Developed by:** [Henri De Witte](https://apify.com/henri_dewitte) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 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.

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 Product Scraper + Price Monitor

Get **every product of any Shopify or WooCommerce shop** in seconds: title, brand, **prices, old prices, discounts, all variants (size/colour), stock, SKU, barcode (EAN/GTIN)**, images, categories and tags. Turn on the **price monitor** and every run tells you which products are **new, cheaper, more expensive, back in stock or sold out** since the last run. Other shops work too, via the schema.org product data on their product pages.

- ✅ Shopify and WooCommerce via their fast public product API: thousands of products per minute, no browser needed
- ✅ Any other shop with schema.org product data (most big shops): found via the sitemap
- ✅ Platform detected automatically; whole shop, one collection/category or one product
- ✅ All variants with their own price, old price, stock, SKU, barcode and options
- ✅ Built-in **price and stock tracking**: `new`, `price-drop`, `price-increase`, `back-in-stock`, `out-of-stock` with the previous price and % change
- ✅ "Only new and changed": a daily competitor price monitor that only returns (and only costs) what changed
- ✅ Same clean format for every platform; prices as numbers (WooCommerce cents converted)
- ✅ One shop down or blocking? The others still run, with a clear message

### Who is it for?

- **E-commerce owners and dropshippers**: watch competitor prices and stock every day.
- **Brands**: see where and for how much resellers sell your products (barcodes and SKUs included).
- **Market researchers and agencies**: export whole catalogues to compare assortments, prices and discounts.
- **Deal and price-comparison sites**: feed new products, price drops and back-in-stock alerts.
- **Developers and AI agents**: one API for product data from very different shops.

### How to use it

1. Add one or more **shops**: a home page (all products), a collection or category page, or one product page.
2. Click **Start**. Shopify and WooCommerce shops are done in seconds.
3. For a **price monitor**: turn on **Only new and changed products** and add a daily **schedule**. The first run returns all products, then only the changes.

### Input examples

Whole shop, one row per product:

```json
{ "storeUrls": ["https://kith.com", "https://woocommerce.com"] }
```

Daily price and stock monitor of one competitor collection, per variant:

```json
{
    "storeUrls": ["https://www.allbirds.com/collections/mens"],
    "splitVariants": true,
    "onlyChanged": true
}
```

| Field                 | Default | Meaning                                                                                |
| --------------------- | ------- | -------------------------------------------------------------------------------------- |
| `storeUrls`           | –       | Shop, collection/category or product URLs (max 1,000)                                  |
| `platform`            | `auto`  | `auto`, `shopify`, `woocommerce` or `jsonld` (other shops)                             |
| `maxProductsPerStore` | all     | Stop after this many products per shop                                                 |
| `splitVariants`       | false   | One row per variant instead of per product                                             |
| `includeDescription`  | true    | Add the description as clean text                                                      |
| `trackChanges`        | true    | Compare with the previous run and fill `change`, `previousPrice`, `priceChangePercent` |
| `onlyChanged`         | false   | Only return new products and products with a price or stock change                     |
| `maxResults`          | 1000    | Maximum rows per run                                                                   |

### Output example

```json
{
    "store": "kith.com",
    "storeName": "Kith",
    "platform": "shopify",
    "productId": "8123456789",
    "title": "Black Suede Studio Brea Mule - Latte Eel",
    "url": "https://kith.com/products/bsbrea-leel",
    "brand": "Black Suede Studio",
    "productType": "Footwear",
    "price": 299,
    "maxPrice": 299,
    "compareAtPrice": null,
    "currency": "USD",
    "available": true,
    "onSale": false,
    "variantCount": 26,
    "variants": [
        {
            "variantId": "4400001",
            "title": "34",
            "sku": "BSBREA-LEEL-34",
            "price": 299,
            "available": true,
            "options": { "Size": "34" }
        }
    ],
    "options": [{ "name": "Size", "values": ["34", "35", "36"] }],
    "imageUrls": ["https://cdn.shopify.com/s/files/1/0094/2252/files/brea.jpg"],
    "change": "price-drop",
    "previousPrice": 345,
    "priceChangePercent": -13.3,
    "scrapedAt": "2026-10-09T08:00:00.000Z"
}
```

The table view shows product, brand, price, old price, stock, variants, change and link. Download as JSON, CSV, Excel or use the API.

### Pricing

**$1 per 1,000 products** (pay per row). With **Only new and changed** you only pay for changes, so a daily monitor of a 2,000-product shop usually costs a few cents per day. Apify's free plan: max 100 products per run.

### Tips

- A **collection or category URL** is the cheapest way to watch only part of a shop.
- With **One row per variant**, every size/colour is a row (more rows = higher cost, but easier in Excel).
- Price tracking is remembered **per shop**, also between different tasks. Keep the same shop URL for a monitor.
- Shops that are not Shopify/WooCommerce need schema.org product data on their product pages. Some big shops block automated visitors (HTTP 403/429): the run summary (key-value store `SUMMARY`) then says so, and the other shops still run.
- WooCommerce's public API does not publish a price per variant: those rows have the product price.

### Data and legal

The Actor only reads public product data that shops publish for search engines and their own website (Shopify `/products.json`, the WooCommerce Store API and schema.org data). It does not log in, does not bypass blocks or captchas, and collects no personal data. Requests are spaced out to be gentle on the shops. Check the terms of the shops you scrape and use the data responsibly.

# Actor input Schema

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

Shop home page (all products), a collection or category page (only those products) or one product page. Examples: https://kith.com, https://www.allbirds.com/collections/mens, https://woocommerce.com/products/. Max 1,000.

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

Leave on "Detect automatically". Shopify and WooCommerce are read via their fast public product API. Other shops are read via the schema.org product data on their product pages (found via the sitemap).

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

Stop after this many products per shop. Leave empty for all products.

## `splitVariants` (type: `boolean`):

One row per size/colour with its own price, stock, SKU and barcode, instead of one row per product (with all variants inside). Note: you pay per row.

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

Add the product description as clean text (max 5,000 characters).

## `trackChanges` (type: `boolean`):

Remember prices and stock between runs. Every row then says what changed: new, price-drop, price-increase, back-in-stock, out-of-stock or unchanged, with the previous price.

## `onlyChanged` (type: `boolean`):

Only return products that are new or whose price or stock changed since the last run. Schedule the Actor daily to get a cheap price and stock monitor of competitors. The first run returns all products.

## `maxResults` (type: `integer`):

Maximum number of rows this run saves (and you pay for).

## Actor input object example

```json
{
  "storeUrls": [
    "https://kith.com"
  ],
  "platform": "auto",
  "splitVariants": false,
  "includeDescription": true,
  "trackChanges": true,
  "onlyChanged": false,
  "maxResults": 1000
}
```

# Actor output Schema

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

No description

## `summary` (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://kith.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("henri_dewitte/shopify-woocommerce-product-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://kith.com"] }

# Run the Actor and wait for it to finish
run = client.actor("henri_dewitte/shopify-woocommerce-product-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://kith.com"
  ]
}' |
apify call henri_dewitte/shopify-woocommerce-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,henri_dewitte/shopify-woocommerce-product-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/myDxaSwXaJdw33qkE/builds/5REhVj2EWhNb9LScq/openapi.json