# WooCommerce Price Tracker (`mighty_monk/woocommerce-price-tracker`) Actor

Track WooCommerce product prices across multiple stores via the Store API. Returns historical price snapshots with regularPrice, salePrice, onSale, and scrapedAt timestamps.

- **URL**: https://apify.com/mighty\_monk/woocommerce-price-tracker.md
- **Developed by:** [Harsh](https://apify.com/mighty_monk) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 price records

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## WooCommerce Price Tracker

Track product prices across multiple WooCommerce stores and export timestamped price snapshots for historical monitoring, competitor analysis, and alerting workflows.

This Actor uses the public **WooCommerce Store API** (`/wp-json/wc/store/v1/products`) with pagination. Each run produces dataset records suitable for comparing prices over time when scheduled regularly.

### Features

- **Multi-store tracking** — monitor prices from several WooCommerce stores in one run
- **Store API** — uses `/wp-json/wc/store/v1/products` with automatic pagination
- **Historical snapshots** — every record includes `scrapedAt`, `regularPrice`, `salePrice`, and `onSale`
- **Retries & rate limiting** — configurable request retries and per-domain delay
- **Error handling** — failed stores produce error records instead of crashing the run
- **Dataset export** — results are saved to the default Apify dataset

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `storeUrls` | `string[]` | Yes | — | WooCommerce store base URLs |
| `maxProductsPerStore` | `integer` | No | `100` | Max price snapshots per store |
| `perPage` | `integer` | No | `100` | Products per API page (max 100) |
| `maxRequestRetries` | `integer` | No | `3` | HTTP retry count |
| `requestDelayMs` | `integer` | No | `500` | Delay between same-domain requests (ms) |
| `maxRequestsPerCrawl` | `integer` | No | `10000` | Safety cap on total requests |

#### Example input

```json
{
  "storeUrls": [
    "https://woocommerce.com"
  ],
  "maxProductsPerStore": 25,
  "perPage": 25,
  "requestDelayMs": 500
}
````

See also [`examples/input.json`](./examples/input.json).

### Output

Each dataset item is a price snapshot:

| Field | Description |
|-------|-------------|
| `productId` | WooCommerce product ID |
| `title` | Product name |
| `sku` | Stock keeping unit |
| `price` | Current price |
| `regularPrice` | Regular price |
| `salePrice` | Sale price |
| `onSale` | Whether the product is on sale |
| `currency` | Currency code (e.g. USD) |
| `permalink` | Product page URL |
| `storeUrl` | Source store URL |
| `scrapedAt` | ISO timestamp of when the price was captured |
| `error` | Error message when tracking failed |

#### Example output

```json
{
  "productId": 123,
  "title": "Sample Product",
  "sku": "SKU-001",
  "price": "29.99",
  "regularPrice": "39.99",
  "salePrice": "29.99",
  "onSale": true,
  "currency": "USD",
  "permalink": "https://example.com/product/sample-product/",
  "storeUrl": "https://example.com",
  "scrapedAt": "2026-07-05T12:00:00.000Z",
  "error": null
}
```

See also [`examples/output.json`](./examples/output.json).

### How it works

1. For each store URL, the Actor normalizes the base URL.
2. It requests page 1 from the WooCommerce Store API (`per_page` configurable).
3. Products are converted into price snapshot records and pushed to the dataset.
4. If more products are available, the next page is enqueued until `maxProductsPerStore` is reached.
5. Failed stores on the first page produce a single error record with `scrapedAt`.

### Scheduling for price history

Run this Actor on a schedule (e.g. daily) and append dataset results to your own database or spreadsheet. Compare `scrapedAt` snapshots by `productId` + `storeUrl` to detect price changes.

### Local development

```bash
npm install
npm test
npm run lint
npm run build
apify run
```

Create `storage/key_value_stores/default/INPUT.json` with your test input, or use the prefill values in the input schema.

### Deploy

```bash
apify login
apify push
```

### Notes

- The Store API must be publicly accessible on the target store.
- Some stores disable or restrict public APIs; those stores will return error records.
- Respect each store's terms of service and robots.txt when scraping.

# Actor input Schema

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

WooCommerce store base URLs to track prices from (e.g. https://example.com).

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

Maximum number of product price snapshots to collect per store.

## `perPage` (type: `integer`):

Number of products to request per Store API page (max 100).

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed HTTP request before giving up.

## `requestDelayMs` (type: `integer`):

Minimum delay between requests to the same domain, in milliseconds.

## `maxRequestsPerCrawl` (type: `integer`):

Safety limit on total HTTP requests per Actor run.

## Actor input object example

```json
{
  "storeUrls": [
    "https://woocommerce.com"
  ],
  "maxProductsPerStore": 100,
  "perPage": 100,
  "maxRequestRetries": 3,
  "requestDelayMs": 500,
  "maxRequestsPerCrawl": 10000
}
```

# Actor output Schema

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mighty_monk/woocommerce-price-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WooCommerce Price Tracker",
        "description": "Track WooCommerce product prices across multiple stores via the Store API. Returns historical price snapshots with regularPrice, salePrice, onSale, and scrapedAt timestamps.",
        "version": "0.0",
        "x-build-id": "RHuGp6IrgDFVYiMEN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mighty_monk~woocommerce-price-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mighty_monk-woocommerce-price-tracker",
                "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/mighty_monk~woocommerce-price-tracker/runs": {
            "post": {
                "operationId": "runs-sync-mighty_monk-woocommerce-price-tracker",
                "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/mighty_monk~woocommerce-price-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-mighty_monk-woocommerce-price-tracker",
                "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": "Store URLs",
                        "type": "array",
                        "description": "WooCommerce store base URLs to track prices from (e.g. https://example.com).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerStore": {
                        "title": "Max products per store",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product price snapshots to collect per store.",
                        "default": 100
                    },
                    "perPage": {
                        "title": "Products per API page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of products to request per Store API page (max 100).",
                        "default": 100
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed HTTP request before giving up.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Minimum delay between requests to the same domain, in milliseconds.",
                        "default": 500
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max requests per crawl",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Safety limit on total HTTP requests per Actor run.",
                        "default": 10000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
