# Product Price Monitor: Shopify, WooCommerce and Any Shop (`tan-solutions/product-monitor`) Actor

Track prices and stock of the shops and products you name: Shopify, WooCommerce and any shop with schema.org product data. Each run lists only new, changed and removed products. Obeys robots.txt, 1 request per second per shop. Pay per product row; unchanged rows and failed shops are free.

- **URL**: https://apify.com/tan-solutions/product-monitor.md
- **Developed by:** [Tan Solutions](https://apify.com/tan-solutions) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 product row delivereds

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

## Product Price Monitor: Shopify, WooCommerce and Any Shop

Track the prices and stock of the shops and products you name. One run reads Shopify stores, WooCommerce shops and any
product page with schema.org product data, and gives you one clean row per product, variant or offer. Give it a
Monitor ID and run it on a schedule: each run then lists only what changed since the last one (new products, price up,
price down, back in stock, sold out, removed). An ecommerce scraper, price monitor and product price tracker in one.

### Quick API and schedule example

Run it from code, then put the same call on a schedule (Apify Console > Schedules) for a daily price check:

```bash
curl -X POST "https://api.apify.com/v2/acts/tan-solutions~product-monitor/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["allbirds.com", "https://shop.example/product/blue-mug/"], "monitorId": "my-shops", "maxItems": 500}'
```

### What it does

- Shop home pages or bare domains: reads the whole public catalogue. Shopify stores through `/products.json` (the feed
  Shopify publishes for every store), WooCommerce shops through their public Store API, page by page.
- Shopify collection pages (`/collections/<handle>`): that collection only.
- Single product pages: Shopify (`/products/<handle>`), WooCommerce (`/product/<slug>/`) or any shop whose page
  carries schema.org `Product` data (JSON-LD). Prices, currency and stock come from that data.
- Home pages of other shops (the site root, or a language home page such as `/fr/` or `/en-us/`): when the home page
  itself carries no product data, the Actor reads the shop's sitemap
  (the `Sitemap:` lines of its robots.txt, else `/sitemap.xml`), keeps the pages that look like product pages
  (sitemaps named for products first, else addresses with `/product/`, `/products/`, `/p/` or `/item/`), skips every
  page robots.txt disallows, and reads each one as a product page, up to "Max products per shop" and at the same
  1 request per second. Shops whose product addresses have no such marker (for example `/blue-mug` or
  `/Blue-Mug/SW10001`, in plain or gzip `.xml.gz` sitemaps): the Actor reads 3 pages spread over each sitemap file
  (largest file first, at most 3 files) and reads the first file whose sample carries product data. It never follows
  links. If the sitemap lists no product pages, the shop gets one free `no_products` row that says so.
- One row per variant or offer, the same shape for every platform: `price` and `compareAtPrice` as numbers,
  `currency` (ISO code), `availability` (`in_stock`, `out_of_stock`, `preorder`, `backorder`, `limited`,
  `discontinued`), `sku`, `image`, `platform` (`shopify`, `woocommerce`, `jsonld`) and `path` (`json` or `jsonld`).
- Stock from schema.org data: all 12 `ItemAvailability` values are read, with `https://schema.org/` or `http://schema.org/`
  in front: InStock, InStoreOnly and OnlineOnly = `in_stock`; OutOfStock, SoldOut and Reserved = `out_of_stock`;
  PreOrder and PreSale = `preorder`; BackOrder and MadeToOrder = `backorder`; LimitedAvailability = `limited`;
  Discontinued = `discontinued`.
- WooCommerce variable products: one row at the lowest price, with `priceIsFrom: true` and the highest price in
  `priceMax`.
- `urlSource` says where a row's `url` comes from: `shop-data` when the shop's own product data gives it
  (WooCommerce permalink, the page's structured data), `fetched` when it is built from the address the Actor read. A
  `shop-data` link can point to another domain of the same shop.
- A shop or URL that cannot be read gets one free `shop` row that says why (`robots_disallowed`, `no_products`,
  `password_protected`, `blocked`, `rate_limited`, `not_found`, `error`, `stopped_by_limit`, `time_budget`,
  `invalid_input`), with the number of products delivered before it stopped. A page without product data gets a free
  `no_products` row.
- Run time: the Actor starts no new request once the run is close to its timeout, so a run on slow shops still ends
  normally. It keeps back enough time for the slowest possible request: the shop's robots.txt and two tries at the
  request timeout, redirects included, a wait of up to 30 seconds when the shop asks for one, and 5 seconds to save
  the summary. That is 127 seconds at the default request timeout of 30 seconds (never less than 10 % of the run and
  never more than half of it; a shop that asks for a slower pace in robots.txt keeps back a little more). **Set the
  run timeout to at least 6 times the request timeout plus 74 seconds: 254 seconds (about 4 minutes) at the default.**
  Shorter runs still read pages, but a very slow shop can then run into the timeout. Each shop not fully read gets
  one free `time_budget` row ("time budget reached; 40 of 100 pages read"); rows already delivered stay, and nothing
  is reported as removed for that shop. Raise the run timeout to read more.

### Who it is for

- E-commerce teams and brands that watch competitors' prices, discounts and stock.
- Resellers, deal finders and analysts who track a list of products across many shops.
- Developers and AI agents that want clean, typed price data from one API call.

### Quick start

1. Add shops or product pages in **Shops or product pages**, one per line: `allbirds.com`, a collection page like
   `https://store.com/collections/sale`, or any product page.
2. Type a **Monitor ID**, for example `my-shops`.
3. Click **Start**. The first run lists every product as `new`.
4. Put the same input on a schedule. From the second run on, the **Output** tab shows only what changed. Download it
   as JSON, CSV or Excel, or read it through the API.

Left empty, the run reads nothing and ends with one free row that asks you to add a shop or product URL.

### Input

| Field (Console name) | What it does | Default |
| --- | --- | --- |
| `startUrls` (Shops or product pages) | Shop home pages, domains, Shopify collections or product pages (at most 50 shops, 500 URLs) | empty (add at least one) |
| `monitorId` (Monitor ID) | Turns on change tracking: use the same ID on every run | empty (off) |
| `onlyChanges` (Only changed products) | With a Monitor ID: list only new, changed and removed products | on |
| `maxItems` (Max rows per run) | Product rows per run across all shops | 20 |
| `maxProductsPerShop` (Max products per shop) | Products read per shop, 1 to 25,000 | 5,000 |
| `maxConcurrency` (Shops in parallel) | Shops read at once, 1 to 5 (each shop still gets 1 request per second) | 3 |
| `timeoutSecs` (Request timeout) | Per request, redirects included, 5 to 120. Keep the run timeout at least 6 times this plus 74 seconds (254 s at 30) | 30 |

```json
{
  "startUrls": ["allbirds.com", "https://kith.com/collections/footwear", "https://shop.example/product/blue-mug/"],
  "monitorId": "my-shops",
  "maxItems": 2000
}
```

#### How change tracking works

Each row gets `change` (`new`, `price_up`, `price_down`, `availability` or `removed`), `previousPrice` and
`previousAvailability`, compared with the last finished run of the same Monitor ID. `availability` and
`previousAvailability` are text states (`in_stock`, `out_of_stock`, `preorder`, `backorder`, `limited`, `discontinued`),
not true/false, because shops state more than in or out of stock. The first run lists every product
as `new`. With "Only changed products" on (the default), unchanged products are left out and cost nothing; turn it off
to get every product with `change: "unchanged"` as well (charged at a lower price). A product counts as `removed` only
when its shop or collection was read to the end, or a product page you named is gone; a run cut short by your limits
or a shop error never reports removals. Keep the same list of URLs per Monitor ID. Without a Monitor ID every row has
`change: null` and the Actor works as a plain ecommerce scraper.

### Output example

A real row from a cloud run (build 0.1.3, 14 Nov 2026, first run of a Monitor ID, so `change` is `new`):

```json
{
  "recordType": "product",
  "status": "ok",
  "shop": "https://colourpop.com",
  "shopDomain": "colourpop.com",
  "sourceUrl": "https://colourpop.com/",
  "platform": "shopify",
  "path": "json",
  "productId": "7449951076434",
  "title": "Liked Christmas a Lot…",
  "updatedAt": "2026-11-14T00:28:41-08:00",
  "priceIsFrom": false,
  "priceMax": null,
  "url": "https://colourpop.com/products/liked-christmas-a-lot-shadow-stix-set?variant=42014435213394",
  "urlSource": "fetched",
  "variantId": "42014435213394",
  "variantTitle": null,
  "sku": "Kit-LikedChristmasALot",
  "price": 16,
  "compareAtPrice": null,
  "currency": "USD",
  "availability": "in_stock",
  "image": "https://cdn.shopify.com/s/files/1/1338/0845/files/Kit-LikedChristmasALot_00461_75fe9a29-0b61-4050-934a-822cb7c5709c.jpg?v=1760723628",
  "change": "new",
  "previousPrice": null,
  "previousAvailability": null,
  "missingFields": [],
  "currencyMissing": false,
  "billable": true,
  "productsDelivered": null,
  "error": null,
  "scrapedAt": "2026-11-14T08:28:40.372Z"
}
```

### Pricing

You pay per product row delivered (the `product` event): every new, changed or removed row, and every row of a run
without a Monitor ID. Unchanged rows left out by "Only changed products" are free; unchanged rows you ask for (the
option off) cost less (`unchanged-json` for shop JSON, `unchanged-html` for product pages).

| Apify plan | Per 1,000 product rows | Per 1,000 unchanged rows (shop JSON / product page) |
| --- | --- | --- |
| Free | $4.00 | $0.30 / $0.80 |
| Bronze | $3.30 | $0.30 / $0.80 |
| Silver | $3.00 | $0.30 / $0.80 |
| Gold, Platinum, Diamond | $2.50 | $0.30 / $0.80 |

Free rows: every `shop` row, rows without a price, rows whose currency is unknown (`currencyMissing: true`), the free
`no_products` row of a page without product data, rows past your "Max products per shop" or "Max rows per run"
settings, and rows over the size limit. A `removed` row is charged like any change. If your spending limit is reached,
the run stops cleanly and tells you so. The run's SUMMARY record (key-value store) counts every charged event. Its `redirects` field lists each redirect hop
the run followed (`from`, `to`, `status`, `n` times); a hop that comes from a robots.txt request is tagged `robots: true`. Apify's
standard Actor start event is charged when a run starts, at the platform's default price.

### Limits

- Speed: one request at a time per shop, at most 1 per second. Shopify reads up to 250 products per page, WooCommerce
  100; each product page is one request. Shops in parallel (up to 5) add up.
- At most 50 different shops and 500 URLs per run, and 25,000 products per shop (default 5,000). The Actor never
  discovers shops by itself and never follows links: it reads the shops, collections and pages you name, and for a
  home page (or language home page such as `/fr/`) without product data the product pages its sitemap lists.
- Coverage: some shops' product pages are not found yet (for example when the shop's sitemap lists no page the Actor
  recognises as a product page). Such a shop gets a free `no_products` row and nothing is charged.
- Public pages only. No login, no cookies, no passwords, no carts, checkouts, accounts, orders or customer data.
  Password-protected shops are reported as `password_protected` and left alone.
- It obeys robots.txt (the `TanForgeBot` token, then `*`) and reads at most 1 request per second per shop.
- It stops a shop at the first block (403 or a bot wall: `blocked`) and after one polite retry on 429 Too Many
  Requests (`rate_limited`). It does not use proxies, rotate addresses or hide who it is.
- It identifies itself as `Mozilla/5.0 (compatible; TanForgeBot/1.0; +https://apify.com/tan-solutions)`. Shop owners can allow or block it in
  robots.txt with the `TanForgeBot` token.
- A shop is fully read when a page comes back with fewer products than asked for (250 on Shopify, 100 on
  WooCommerce); no further page is asked for. A shop that sends the same full page for every page number is read from
  its first page only, and with a Monitor ID it then reports no removed products. A free `shop` row (status `ok`, code
  `PAGES_REPEAT`) says so.
- Shopify's catalogue feed names no currency: the Actor takes it from one page of the shop. If no page states it, the
  rows are delivered free with `currencyMissing: true`.

### FAQ

**Which shops work?** Shopify stores and WooCommerce shops that keep their public catalogue on, and any product page
with schema.org `Product` data (most shop platforms add it for search engines). Anything else gets a free row.

**How fresh is the data?** It is read live at run time; `scrapedAt` says when.

**Do I pay for products that did not change?** No, with "Only changed products" on (the default).

**Can I call it from an AI agent?** Yes, through the Apify API, SDKs or MCP: pass `startUrls` and `monitorId`, read
the dataset items.

### Related tools by Tan Solutions

- [Shopify Store Products](https://apify.com/tan-solutions/shopify-products): the full catalogue of Shopify stores,
  with every variant, tag and image.
- [Website Change Monitor](https://apify.com/tan-solutions/website-change-monitor): get told when any web page changes.
- [URL to Markdown](https://apify.com/tan-solutions/url-to-markdown): turn any web page into clean Markdown for AI and search.

### Your responsibilities

You are responsible for the shops and pages you submit and for lawful use of the data you get back (each shop's terms,
database and copyright rights, and competition law). The Actor reads only public product data, obeys robots.txt, does
not log in and stops at blocks. It is provided without warranty; liability is capped at the fees you paid in the last
12 months. Questions and issues are answered within 14 days through the Actor's Issues tab.

Not affiliated with or endorsed by Shopify, WooCommerce or Automattic. All product names belong to their owners.

Made by Tan Solutions.

# Actor input Schema

## `startUrls` (type: `array`):

One per line: a shop home page or bare domain (all products: Shopify or WooCommerce), a Shopify collection page (https://shop.com/collections/sale), or a single product page of any shop with schema.org product data. Bare domains get https://. At most 50 different shops and 500 URLs per run; the Actor never discovers shops or pages by itself. Left empty, the run ends at once with one free row that asks for a URL.

## `monitorId` (type: `string`):

Give the same ID on every run (for example my-shops) and each row gets change: new, price_up, price_down, availability or removed, compared with the last run of this ID. Letters, digits and -, up to 40 characters. Left empty: every row is listed once, with no comparison.

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

With a Monitor ID: list only new, changed and removed products; unchanged ones are left out and not charged. Off lists every product with change: unchanged (charged at the lower unchanged price). Ignored without a Monitor ID.

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

The run stops cleanly after this many product rows across all shops (one row per variant or offer). Shop rows do not count.

## `maxProductsPerShop` (type: `integer`):

Products past this number are not read (and not charged). Hard limit 25,000 per shop.

## `maxConcurrency` (type: `integer`):

How many shops are read at once. Each shop still gets 1 request at a time, 1 second apart.

## `timeoutSecs` (type: `integer`):

Per request, from request to full body, redirects included. Keep the run timeout at least 6 times this value plus 74 seconds (254 seconds at the default of 30), so the slowest request still ends before the run does.

## Actor input object example

```json
{
  "onlyChanges": true,
  "maxItems": 20,
  "maxProductsPerShop": 5000,
  "maxConcurrency": 3,
  "timeoutSecs": 30
}
```

# Actor output Schema

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

One row per product, variant or offer: change, price, previous price, currency and stock.

## `shops` (type: `string`):

One row per shop or URL that could not be read, with the reason and the products delivered before it stopped.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("tan-solutions/product-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("tan-solutions/product-monitor").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 '{}' |
apify call tan-solutions/product-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tan-solutions/product-monitor"
        }
    }
}
```

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/cW8jrYjYXNRNrgYHd/builds/WtDgPLa31U3pOfoI8/openapi.json
