# Shopify & WooCommerce Products Scraper: Prices, Stock & Changes (`webobsidians/shopify-woocommerce-products-scraper`) Actor

Get every product from any Shopify or WooCommerce store: prices, sale prices, variants, SKUs, stock status, images and categories in one clean format. Track competitors with a built-in monitor that returns only new products and price or stock changes.

- **URL**: https://apify.com/webobsidians/shopify-woocommerce-products-scraper.md
- **Developed by:** [Web Obsidians](https://apify.com/webobsidians) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $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 Products Scraper

Get every product from any **Shopify** or **WooCommerce** store in one clean format: titles, prices, sale prices, variants, SKUs, stock status, images, categories and tags. Paste store URLs or domains; the Actor detects the platform for you.

Turn on **Return only changes** and schedule the Actor to track competitors: each run returns only new products and products whose price or stock changed.

### Why this Actor

- **Shopify and WooCommerce in one run.** Mix both platforms in the same input and get the same fields for every product.
- **Fast and light.** It reads the public product feeds that the stores publish (`/products.json` on Shopify, the Store API on WooCommerce). No browser, no login, no proxies.
- **Price and stock monitoring built in.** The monitor remembers what it saw and returns only new products, price changes (with the previous price) and stock changes.
- **Collections.** Paste a Shopify collection URL (for example `store.com/collections/sale`) to scrape just that collection.
- **Cheap and predictable.** $1.00 per 1,000 products. Platform usage is included.

### Use cases

- **Competitor price monitoring:** get a daily list of price drops, new products and items that went out of stock.
- **E-commerce research:** compare catalogs, price ranges and assortment across stores in a niche.
- **Product feeds and catalogs:** export a store's catalog to JSON, CSV, Excel or Google Sheets.
- **AI agents:** give your agent clean, current product data with prices and availability.

### How to use

1. Add stores to **Stores**, one per line: a domain (`colourpop.com`), a store URL, or a Shopify collection URL.
2. Optionally set filters: keywords, excluded words, price range, in stock only, on sale only.
3. Click **Start**. Download the results as JSON, CSV or Excel, or connect them to Google Sheets, Make, Zapier or n8n.

#### Input example

```json
{
  "stores": [
    "https://colourpop.com",
    "https://www.allbirds.com/collections/mens",
    "https://woocommerce.com"
  ],
  "keywords": ["shoe", "lip"],
  "onlyAvailable": true,
  "maxProductsPerStore": 200
}
```

#### Track price and stock changes every day

Set **Return only changes** to on and give the monitor a name (for example `competitors`). Then create a schedule in Apify Console. The first run returns all products and remembers them; each later run returns only:

- `new`: products that were not in the store before,
- `price`: products whose lowest price, highest price or compare-at price changed (see `previousPrice`),
- `availability`: products that went in or out of stock (see `previousAvailable`),
- `variants`: products where only a variant's price or stock changed.

You pay only for the products that are returned.

### Output

Each product is one item in the dataset:

```json
{
  "store": "www.allbirds.com",
  "platform": "shopify",
  "productId": "7205197709392",
  "handle": "mens-dasher-nz-blizzard",
  "title": "Men's Dasher NZ - Blizzard (Blizzard Sole)",
  "brand": "Allbirds",
  "productType": "Shoes",
  "categories": [],
  "tags": [
    "bfcm-mens",
    "FINAL SALE",
    "OOS DNS"
  ],
  "url": "https://www.allbirds.com/products/mens-dasher-nz-blizzard",
  "currency": "USD",
  "price": 98,
  "priceMax": 98,
  "compareAtPrice": 140,
  "onSale": true,
  "available": true,
  "sku": null,
  "variantCount": 13,
  "variants": [
    {
      "variantId": "41271214374992",
      "title": "8",
      "sku": "A12445M080",
      "price": 98,
      "compareAtPrice": 140,
      "available": true,
      "options": [
        "8"
      ]
    },
    {
      "variantId": "41271214407760",
      "title": "8.5",
      "sku": "A12445M085",
      "price": 98,
      "compareAtPrice": 140,
      "available": true,
      "options": [
        "8.5"
      ]
    }
  ],
  "imageUrl": "https://cdn.shopify.com/s/files/1/1104/4168/files/A12447_26Q1_Dasher-NZ-Blizzard-Blizzard_PDP_LEFT.png?v=1768948090",
  "imageCount": 5,
  "rating": null,
  "reviewCount": null,
  "createdAt": "2025-08-07T03:03:38Z",
  "updatedAt": "2026-11-17T22:54:43Z",
  "publishedAt": "2026-09-25T22:20:39Z",
  "description": null,
  "scrapedAt": "2026-11-17T22:54:43Z",
  "change": null,
  "previousPrice": null,
  "previousAvailable": null
}
```

(`tags` and `variants` are shortened here; the real item has all of them.)

Field notes:

- `price` is the lowest variant price and `priceMax` the highest, in the store's `currency`.
- `compareAtPrice` is the original price when the product is on sale (`onSale: true`).
- `available` is `true` when at least one variant is in stock, `false` when none is, and `null` when the store does not publish stock.
- WooCommerce stores publish variant names but not variant prices or stock, so WooCommerce `variants` contain names only. `createdAt` and `updatedAt` are available for Shopify only.
- A per-store summary (platform, currency, products fetched, any error) is saved to the key-value store as `SUMMARY`.

### Pricing

This Actor uses pay-per-event pricing:

- **$1.00 per 1,000 products** saved to the dataset ($0.001 per product).
- **$0.00005 per run start.**

Platform usage (compute and storage) is included. For example, a store with 1,000 products costs about $1.00, and a daily monitor that returns 30 changes a day costs about $0.90 a month. If you set a maximum cost per run, the Actor stops cleanly when it is reached.

### FAQ

**Which stores work?**
Any public Shopify store and any WooCommerce store with the Store API enabled (the default since WooCommerce 6.x). Password-protected stores and stores that turned off their product feed are reported in `SUMMARY` with an error.

**Can I scrape only part of a Shopify store?**
Yes. Paste a collection URL such as `https://store.com/collections/sale`. For WooCommerce, use **Keywords** to narrow the results by title, tags or categories.

**Why is `currency` empty for some Shopify stores?**
The Actor reads the currency from the store's public cart endpoint. A few stores block it; prices are still in the store's default currency.

**How many products can it get?**
All public products. Large stores take longer because the Actor reads politely, one page at a time.

# Actor input Schema

## `stores` (type: `array`):

One store per line: a domain (colourpop.com), a store URL, or a Shopify collection URL (store.com/collections/sale). Works with any public Shopify or WooCommerce store; the platform is detected automatically.

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

Stop after this many products per store (after filters). 0 means all products.

## `keywords` (type: `array`):

Keep products whose title, type, tags or categories contain at least one of these words (not case-sensitive), e.g. hoodie, serum, coffee.

## `excludeKeywords` (type: `array`):

Drop products whose title contains any of these words, e.g. gift card, sample.

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

Keep products whose lowest price is at least this much, in the store's currency.

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

Keep products whose lowest price is at most this much, in the store's currency.

## `onlyAvailable` (type: `boolean`):

Keep only products with at least one variant in stock.

## `onlyOnSale` (type: `boolean`):

Keep only products with a sale price (compare-at or regular price above the current price).

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

Add the list of variants (size, color...) with their own price, SKU and stock to each product. WooCommerce stores publish variant names only.

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

Add the product description as plain text. Makes the output larger.

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

Return only products that are new or whose price or stock changed since earlier runs with the same monitor name. The first run returns everything and remembers it.

## `monitorName` (type: `string`):

Use different names to keep separate histories, for example one per competitor or per client.

## Actor input object example

```json
{
  "stores": [
    "https://colourpop.com",
    "https://www.allbirds.com/collections/mens",
    "https://woocommerce.com"
  ],
  "maxProductsPerStore": 50,
  "onlyAvailable": false,
  "onlyOnSale": false,
  "includeVariants": true,
  "includeDescription": false,
  "onlyChanges": false,
  "monitorName": "default"
}
```

# Actor output Schema

## `products` (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 = {
    "stores": [
        "https://colourpop.com",
        "https://www.allbirds.com/collections/mens",
        "https://woocommerce.com"
    ],
    "maxProductsPerStore": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("webobsidians/shopify-woocommerce-products-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 = {
    "stores": [
        "https://colourpop.com",
        "https://www.allbirds.com/collections/mens",
        "https://woocommerce.com",
    ],
    "maxProductsPerStore": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("webobsidians/shopify-woocommerce-products-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 '{
  "stores": [
    "https://colourpop.com",
    "https://www.allbirds.com/collections/mens",
    "https://woocommerce.com"
  ],
  "maxProductsPerStore": 50
}' |
apify call webobsidians/shopify-woocommerce-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,webobsidians/shopify-woocommerce-products-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/y71dTU8tudUCPgOIU/builds/H23mjLEEhXAmK6TIE/openapi.json
