# Agent Commerce Watch \[$1/1K💰] | Price & Stock Monitor (`ahmed_jasarevic/agent-commerce-watch`) Actor

Monitor Shopify, WooCommerce and JSON-LD store prices and stock, and get typed change events (price drops, restocks, sell-outs) via an MCP server for AI agents.

- **URL**: https://apify.com/ahmed_jasarevic/agent-commerce-watch.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 product snapshots

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Agent Commerce Watch — Price & Stock MCP for AI Agents

Track e-commerce prices, discounts and stock across Shopify and WooCommerce stores (plus any storefront with Product JSON-LD) and return one normalized product shape plus typed change events — built as an MCP server so AI agents can call it directly.

Agent Commerce Watch reads stores through their public JSON APIs and sitemap product pages, keeps a per-store baseline in a key-value store, and on each scheduled run emits only what changed: price drops and rises, sales, restocks, sell-outs, new and removed products and variant changes. No browser is required for supported stores, which keeps scans fast and cheap enough for scheduled monitoring.

### Monitor Competitor Prices & Stock For E-Commerce Intelligence

- **Competitor price and stock monitoring** — know within the schedule window when a store cuts prices, raises them, or sells out.
- **MAP and reseller enforcement** — catch resellers pricing below your minimum, with a timestamped record and variant detail.
- **Restock and launch alerts** — detect back-in-stock events and newly listed products the moment they appear.
- **Catalog snapshots for analytics** — export a clean, normalized product catalog from any Shopify or WooCommerce store.
- **Agent-driven commerce tools** — expose store scanning, product lookup and change feeds to an AI agent over MCP.

### How It Works

![How Agent Commerce Watch works: store scans and baselines become normalized product rows and typed price, stock and variant change events.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-agent-commerce-watch)

The Actor detects Shopify, WooCommerce or generic JSON-LD storefronts, reads their public catalog surfaces over HTTP and normalizes every product into one shape. In monitor mode it keeps a per-store baseline in a key-value store and compares each run against it.

Output is either a product snapshot with price, compare-at price, discount, stock and variants, or a typed change event such as price_drop, back_in_stock or new_product. The same tools are exposed over MCP for AI agents.

1. **Platform detection** — the store is identified as Shopify (`/meta.json`, `/products.json`), WooCommerce (Store API at `/wp-json/wc/store/v1/products`) or generic (sitemap + JSON-LD), or pinned manually via `platform`.
2. **Catalog or product read** — products are read from the store's own public endpoints (Shopify `/products.json`, WooCommerce Store API, or JSON-LD / OpenGraph / microdata / HTML for generic stores).
3. **Normalization** — every product is returned in one consistent shape with price, compare-at price, discount percent, currency, availability, SKU, brand, category and images.
4. **Change detection (monitor mode)** — a baseline is saved per store in the `agent-commerce-watch-state` key-value store; each later run compares against it and emits only typed change events.

Platform detection results are cached for 7 days; genuine generic scans are cached for 1 day. For supported stores, no browser is used.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `mode` | string | No | `scan` | `scan` (once) or `monitor` (baseline then changes). |
| `stores` | array | No | — | Store domains or URLs for batch scans. |
| `store` | string | No | — | Single store used when `stores` is empty. |
| `urls` | array | No | — | Exact product URLs to scan. |
| `maxProductsPerStore` | integer | No | `100` | Product cap per store. |
| `includeVariants` | boolean | No | `true` | Include variant-level price and stock. |
| `platform` | string | No | `auto` | `auto`, `shopify`, `woocommerce` or `generic`. |
| `onlyChanges` | boolean | No | `true` | In monitor mode, push change rows only. |
| `emitFirstSeen` | boolean | No | `false` | Emit `first_seen` events on the first monitor run. |
| `webhookUrl` | string | No | — | POST monitor events to this URL. |
| `requestDelayMs` | integer | No | `150` | Delay between generic product page requests. |
| `proxyConfiguration` | object | No | disabled | When enabled, the proxy is used only as a fallback after a direct request fails. |

### Output Fields

**Product rows:** `store`, `platform`, `productId`, `title`, `url`, `sku`, `brand`, `category`, `price`, `priceMin`, `priceMax`, `compareAtPrice`, `discountPercent`, `currency`, `availability`, `inStock`, `variants`, `image`, `description`, `tags`, `rating`, `reviewCount`, `confidence`, `source`, `scrapedAt`.

**Change rows:** `detectedAt`, `event`, `store`, `platform`, `title`, `previousPrice`, `currentPrice`, `priceDelta`, `priceDeltaPct`, `previousAvailability`, `availability`, `variantTitle`, `message`, `url`.

Change events include: `price_drop`, `price_rise`, `sale_started`, `sale_ended`, `back_in_stock`, `out_of_stock`, `availability_changed`, `new_product`, `removed`, `first_seen`, `variant_added`, `variant_removed`, `variant_price_drop`, `variant_price_rise`, `variant_back_in_stock`, `variant_out_of_stock`.

### Example Input

Scan a store catalog and a list of exact product URLs:

```json
{
  "mode": "scan",
  "stores": ["allbirds.com", "saman.ca"],
  "maxProductsPerStore": 50,
  "includeVariants": true
}
```

Monitor a store and emit only changes:

```json
{
  "mode": "monitor",
  "stores": ["allbirds.com"],
  "maxProductsPerStore": 100,
  "includeVariants": true,
  "onlyChanges": true,
  "emitFirstSeen": false
}
```

### Example Output

Product row:

```json
{
  "store": "allbirds.com",
  "platform": "shopify",
  "productId": "1234567",
  "title": "Women's Wool Runner",
  "url": "https://www.allbirds.com/products/womens-wool-runner",
  "price": 98,
  "compareAtPrice": 110,
  "discountPercent": 10,
  "currency": "USD",
  "availability": "in_stock",
  "inStock": true,
  "sku": "WR-001",
  "brand": "Allbirds",
  "scrapedAt": "2026-10-20T12:00:00.000Z"
}
```

Change row:

```json
{
  "detectedAt": "2026-10-21T06:00:00.000Z",
  "event": "price_drop",
  "store": "allbirds.com",
  "platform": "shopify",
  "title": "Women's Wool Runner",
  "previousPrice": 110,
  "currentPrice": 98,
  "priceDelta": -12,
  "priceDeltaPct": -10.9,
  "availability": "in_stock",
  "variantTitle": "Size 8",
  "message": "Price dropped from $110 to $98 (-10.9%)",
  "url": "https://www.allbirds.com/products/womens-wool-runner"
}
```

### Automate Price Monitoring With Schedules & Webhooks

- **Schedule monitor mode** (hourly, daily or weekly) so each run reports only what changed since the last one.
- **Set `webhookUrl`** to receive one JSON payload per store containing the detected events — pipe it to Slack, email, Zapier, Make or your own service.
- **Register stores with the `watch_store` MCP tool**, schedule the Actor in monitor mode, then read `get_changes` from your agent.
- **Reuse the baseline state** stored in `agent-commerce-watch-state` between runs, so no re-dumping of unchanged catalogs.

### Related Actors

- [Shopify Product Scraper](https://apify.com/ahmed_jasarevic/shopify-product-scraper) — deep Shopify catalog, inventory and variant extraction.
- [Shopify Scraper](https://apify.com/ahmed_jasarevic/shopify-scraper) — Shopify tech stack, apps and themes intelligence.
- [Idealo Scraper](https://apify.com/ahmed_jasarevic/idealo-scraper) — price comparison data across European marketplaces.
- [Slickdeals Scraper](https://apify.com/ahmed_jasarevic/slickdeals-scraper) — deals and discount tracking across retailers.
- [ProductReview Scraper](https://apify.com/ahmed_jasarevic/productreview-scraper) — customer review and sentiment data for products.

### Frequently Asked Questions

#### Why use this Actor instead of the official store API?

Shopify and WooCommerce expose public product endpoints, but not a change feed or a cross-platform normalized shape. This Actor reads those public endpoints, normalizes every store into one schema, and adds stateful change detection so you get what moved — not the whole catalog every run.

#### What are alternatives to this Actor?

Other approaches include building your own Shopify `/products.json` — or WooCommerce Store API — poller with a diffing layer, or using a single-platform price monitor. This Actor covers Shopify, WooCommerce and generic JSON-LD stores in one run and also exposes an MCP server for agents.

#### Do I need a browser or API key?

No. Supported stores are read through their public JSON endpoints with no login and no browser. Generic stores behind bot protection may block requests even when their sitemap is public.

#### How does monitor mode track changes?

The first run creates a baseline per store in the `agent-commerce-watch-state` key-value store. Later runs compare against it and emit typed change events. Without a schedule, there are no new change events to read.

#### Can AI agents call it directly?

Yes. The Actor runs in standby mode and serves MCP over Streamable HTTP at `/mcp`, exposing `scan_store`, `get_product`, `compare_products`, `watch_store` and `get_changes`.

### For AI Agents & LLM Apps

Purpose: return a normalized store catalog or a feed of detected price/stock changes, callable over MCP or the Apify API.

Minimal working input (scan):

```json
{ "mode": "scan", "store": "allbirds.com", "maxProductsPerStore": 20 }
```

Minimal working input (monitor):

```json
{ "mode": "monitor", "store": "allbirds.com", "onlyChanges": true }
```

Output fields: `store, platform, productId, title, url, sku, brand, category, price, priceMin, priceMax, compareAtPrice, discountPercent, currency, availability, inStock, image, scrapedAt` (products) and `detectedAt, event, store, previousPrice, currentPrice, priceDelta, priceDeltaPct, availability, variantTitle, message, url` (changes).

MCP server: Streamable HTTP at `https://YOUR-STANDBY-URL/mcp`, with tools `scan_store`, `get_product`, `compare_products`, `watch_store`, `get_changes`.

Behaviors an agent should know:

- If neither `stores`/`store` nor `urls` is provided, the Actor runs a small **demo scan of `allbirds.com` (max 5 products)**.
- `store` (singular) is used only when `stores` is empty; `urls` scans exact products without catalog discovery.
- `onlyChanges` defaults to `true` in monitor mode; set `emitFirstSeen: true` only if the first run should emit `first_seen` for every product (leave off for large catalogs).
- `mode: "monitor"` requires a prior baseline to produce changes; there is no state until the first run.
- `webhookUrl` adds one POST per store with the detected events.
- Billing: pay-per-event — `MCP tool call` $0.005 (primary), `Product snapshot` $0.002, `Product check` $0.001, `Price or stock change` $0.002.

### Legal & Compliance Disclaimer

This is an independent Actor. It is not affiliated with, endorsed by, or sponsored by Shopify, WooCommerce, WordPress, or any store it reads. It accesses only publicly available product endpoints and pages — no login is performed, no CAPTCHA solving is performed, and no access controls are used. Product prices are approximate and should be verified on the product page before a purchase. Users are responsible for complying with each store's Terms of Service, robots directives, rate limits and applicable law (including data-protection law where any personal data is involved) when using the data.

### SEO Keywords

price monitor, stock monitor, product price tracker, shopify price monitor, woocommerce price monitor, competitor price tracking, price drop alerts, back in stock alerts, product stock scraper, shopify scraper, woocommerce scraper, ecommerce price monitoring, product json-ld scraper, price change detection, mcp server for ecommerce, ai agent product data, catalog monitoring, map pricing enforcement, restock alerts, price and availability api

# Actor input Schema

## `mode` (type: `string`):

scan = return the current catalog. monitor = re-check the same stores, compare against the previous run and emit only changes (plus an optional webhook). In monitor mode with no stores set, the watchlist registered through the MCP watch_store tool is used.

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

Store domains or URLs, e.g. allbirds.com or https://www.allbirds.com. Shopify and WooCommerce are detected automatically; other stores fall back to sitemap + Product JSON-LD.

## `store` (type: `string`):

A single store domain or URL. Used when stores is empty.

## `urls` (type: `array`):

Scan these exact product pages instead of whole stores. Works for any store and is the fastest way to check a handful of products.

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

Cap on products returned per store. Shopify and WooCommerce use bulk endpoints and handle thousands of products cheaply. Generic sitemap scans fetch one page per product, so keep this low (25-100).

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

Include variant-level price and stock. Shopify variants are free (already in the catalog response). WooCommerce variants require extra requests and are fetched only for the first 50 variable products per scan.

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

Auto-detect probes Shopify and WooCommerce endpoints and caches the result per store. Force a platform if detection is blocked.

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

monitor mode only — push a row only when something changed. Disable to also push a current snapshot of every product.

## `emitFirstSeen` (type: `boolean`):

monitor mode only — on the very first check, emit a first_seen event for every product instead of silently creating a baseline. Keep this off for large catalogs.

## `webhookUrl` (type: `string`):

monitor mode only — POST one JSON payload per store containing the detected change events (price drops, rises, stock changes, new and removed products).

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

Only used for generic sitemap scans and product-by-URL requests. Adds a polite delay between page fetches.

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

Proxy is off by default. When enabled, it is used only as a fallback after a direct request fails, so stores that allow direct access stay fast. Residential proxies are required for strict anti-bot stores such as Gymshark.

## Actor input object example

```json
{
  "mode": "scan",
  "stores": [
    "colourpop.com",
    "kyliecosmetics.com",
    "saman.ca"
  ],
  "maxProductsPerStore": 500,
  "includeVariants": true,
  "platform": "auto",
  "onlyChanges": true,
  "emitFirstSeen": false,
  "requestDelayMs": 150,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per product (scan mode) or per change event (monitor mode). Switch between the Commerce rows, Product catalog and Price & stock changes views in the table. Append ?format=json or ?format=csv to download.

## `summary` (type: `string`):

Store, product, change and error counts plus elapsed time for this run.

# 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": [
        "colourpop.com",
        "kyliecosmetics.com",
        "saman.ca"
    ],
    "maxProductsPerStore": 500,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/agent-commerce-watch").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": [
        "colourpop.com",
        "kyliecosmetics.com",
        "saman.ca",
    ],
    "maxProductsPerStore": 500,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/agent-commerce-watch").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": [
    "colourpop.com",
    "kyliecosmetics.com",
    "saman.ca"
  ],
  "maxProductsPerStore": 500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/agent-commerce-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/agent-commerce-watch"
        }
    }
}
```

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/Y9mupZmhuAEGIHpet/builds/1uDdnlbgbsKUDcHdn/openapi.json