# BigCommerce Price & Stock Delta Monitor (`clintsa/bigcommerce-price-stock-delta-monitor`) Actor

Monitor public BigCommerce storefronts for stateful price, stock, sale-start, and product-removed deltas from sitemaps and JSON-LD.

- **URL**: https://apify.com/clintsa/bigcommerce-price-stock-delta-monitor.md
- **Developed by:** [Andy Besos](https://apify.com/clintsa) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 bigcommerce delta events

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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Monitor any public BigCommerce storefront through its published sitemap and product-page JSON-LD. BigCommerce Price & Stock Delta Monitor returns normalized SKU-level prices, sale prices, availability, conditions, product URLs, and typed change events for scheduled competitive monitoring.

You do not need a BigCommerce account, merchant API key, storefront credentials, or a browser. The Actor reads only public `robots.txt`, sitemap XML, HTML, JSON-LD, and publicly embedded BigCommerce product data. Use a normal storefront hostname or URL as input; sitemap discovery is automatic.

### Why use this BigCommerce scraper?

- Discover product pages from `robots.txt`, `/sitemap.xml`, `/sitemap_products.xml`, and legacy BigCommerce `xmlsitemap.php` product sitemaps. You do not need to find or maintain a feed URL manually.
- Track the fields buyers use for price intelligence: SKU, effective price, regular price, sale price, compare-at price, currency, availability, item condition, and optional public inventory level.
- Receive typed events including `price-drop`, `price-increase`, `sale-start`, `sale-end`, `back-in-stock`, `sold-out`, `product-removed`, `new-product`, and `updated`.
- Get `oldValues` and `newValues` for changed fields, plus the source product URL, so a downstream workflow can alert, reprice, or open a review task without scraping the page again.
- Persist a complete per-store snapshot in Apify Key-Value Store. Output limits are applied after reconciliation, so a small output limit does not create phantom removal events.
- Filter scheduled runs to changes detected after an ISO timestamp with `onlyChangesSince`. The first successful run establishes the baseline.

Requests use retries with backoff for temporary failures. A failed product page is isolated from the rest of its storefront, and a failed storefront is isolated from other targets. The run fails only when every target fails.

### Pricing

The Actor uses pay-per-event pricing: $0.0005 per run plus $0.002 per exported dataset result.

| Results | Actor event price |
| ---: | ---: |
| 1 | $0.0025 |
| 100 | $0.2005 |
| 1,000 | $2.0005 |
| 10,000 | $20.0005 |

The exact formula is `$0.0005 per run plus $0.002 per result` before any tier discount. A result is one row written to the default dataset; a change-only run with no detected changes writes no result rows. Standard Apify charges for retaining or downloading data may apply.

### How to use this Actor

`targets` accepts a storefront hostname (`catalyst-demo-site.mybigcommerce.com`), an origin URL (`https://www.prodryers.com/`), or a pasted sitemap URL. The Actor normalizes these to the storefront hostname. Add one or several storefronts.

#### Quick start

```json
{
  "targets": ["https://catalyst-demo-site.mybigcommerce.com/"],
  "maxItemsPerTarget": 1
}
```

The prefilled example uses one public BigCommerce demo storefront and one exported row, making the first health check fast. Set `maxItemsPerTarget` to `0` to export every event. The full storefront snapshot is still reconciled regardless of this output limit.

#### Multiple stores and a respectful crawl delay

```json
{
  "targets": ["www.prodryers.com", "catalyst-demo-site.mybigcommerce.com"],
  "maxItemsPerTarget": 100,
  "requestDelayMillis": 1000
}
```

For a storefront that blocks direct datacenter traffic, you can enable the optional Apify Proxy fallback:

```json
{
  "targets": ["https://example-bigcommerce-store.com"],
  "useApifyProxy": true,
  "maxItemsPerTarget": 0
}
```

### Monitor new, updated, and removed records

Run the Actor on a schedule with the same `monitorId` and target list. State is kept separately for each storefront and monitor ID.

```json
{
  "targets": ["www.prodryers.com"],
  "monitorId": "reseller-map-watch",
  "onlyChangesSince": "2026-09-01T00:00:00.000Z",
  "maxItemsPerTarget": 0
}
```

The first successful run labels observed products `new` and creates the baseline. Later runs emit the following states and typed `eventType` values:

| `changeType` | Meaning |
| --- | --- |
| `new` | A SKU or product URL was not in the previous successful snapshot. |
| `updated` | One or more monitored fields changed; `changedFields` names them. |
| `unchanged` | The product remains present with the same monitored values. |
| `removed` | A product previously present in the complete sitemap snapshot disappeared. |

For example, a regular-price decrease is `changeType: "updated"` and `eventType: "price-drop"`; a product absent from the next full sitemap is `changeType: "removed"` and `eventType: "product-removed"`. A removal is emitted once when first detected.

### API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/Clintsa~bigcommerce-price-stock-delta-monitor/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targets": ["https://catalyst-demo-site.mybigcommerce.com/"],
    "monitorId": "demo-watch",
    "maxItemsPerTarget": 10
  }'
```

### Input options

| Field | Type | What it controls |
| --- | --- | --- |
| `targets` | string array | Required storefront hostnames or URLs. |
| `maxItemsPerTarget` | integer | Exported rows per target; `0` means no limit. Defaults to `1`. |
| `monitorId` | string | Persistent namespace for an independent stateful watch. |
| `onlyChangesSince` | ISO timestamp | Excludes unchanged rows and changes detected before this time. |
| `requestDelayMillis` | integer | Delay between product-page requests, from 0 to 60,000 ms. |
| `useApifyProxy` | boolean | Uses Apify Proxy as an optional fallback. |
| `proxyConfiguration` | object | Proxy settings used when `useApifyProxy` is enabled. |

### Output

Each Dataset row is a product or SKU observation with event metadata:

```json
{
  "target": "catalyst-demo-site.mybigcommerce.com",
  "itemId": "sku:CC3C",
  "sku": "CC3C",
  "name": "[Sample] Chemex Coffeemaker 3 Cup",
  "productUrl": "https://catalyst-demo-site.mybigcommerce.com/chemex-coffeemaker-3-cup/",
  "price": 39.5,
  "regularPrice": 49.5,
  "salePrice": 39.5,
  "compareAtPrice": 59,
  "priceCurrency": "USD",
  "inStock": true,
  "inventoryLevel": 7,
  "availability": "in_stock",
  "changeType": "updated",
  "eventType": "price-drop",
  "changedFields": ["price", "salePrice"],
  "oldValues": {"price": 49.5, "salePrice": null},
  "newValues": {"price": 39.5, "salePrice": 39.5},
  "scrapedAt": "2026-09-01T10:00:00.000Z"
}
```

The Actor also writes a `SUMMARY` record containing requested, successful, and failed targets, fetched records, exported rows, generic change totals, typed event totals, proxy usage, monitor ID, and completion time.

### Use cases

- Brand-protection and MAP-compliance teams checking reseller prices and sale changes.
- Competitive-intelligence teams building SKU-level price and availability histories.
- Dropshippers watching supplier or competitor catalog changes for repricing workflows.
- Merchandising teams routing restock, sold-out, sale-start, and product-removal alerts.
- Automation builders sending change-only rows to Make, n8n, Slack, Sheets, or a BI pipeline.

### FAQ

#### Do I need a BigCommerce API key?

No. The Actor uses public storefront pages and published sitemaps only. It does not access a merchant account or BigCommerce Admin API.

#### Can I monitor a store without knowing its product feed URL?

Yes. Enter the storefront URL or hostname. The Actor checks `robots.txt` and common BigCommerce sitemap paths, including the legacy product sitemap endpoint.

#### Does the Actor return exact stock quantities?

Only when the storefront publicly embeds an inventory number. Most Product JSON-LD exposes a reliable in-stock flag rather than units on hand; `inventoryLevel` is therefore nullable.

#### Does the first run send alerts for every product?

The first run establishes a baseline and labels rows `new`. Use `onlyChangesSince` on later scheduled runs when you want only new, updated, or removed events.

#### Can I monitor several storefronts?

Yes. Add multiple `targets`; every row contains its normalized `target` and product URL. Failed stores do not discard successful stores.

#### What happens when a product is removed?

After a successful full sitemap crawl, a previously observed SKU or product URL missing from the next snapshot is emitted as `product-removed` exactly once.

#### Can I use a proxy?

Most public BigCommerce storefronts work with direct HTTP. Enable `useApifyProxy` only when a target's WAF blocks direct requests. A target may still deny automated access.

### Limitations and responsible use

This Actor returns only information publicly published by each storefront. It does not return private inventory, customer-specific pricing, login-only offers, cart pricing, order data, or data hidden behind JavaScript challenges. JSON-LD and embedded page data vary by theme, so fields that a store does not publish are `null`; exact stock quantities are not inferred. A `price-drop` is an observation of a public page change, not proof of a sale's duration, MAP violation, availability for every customer, or commercial intent. Respect `robots.txt`, the target site's terms, applicable privacy and computer-access laws, and reasonable crawl rates. Use exported observations lawfully and verify important decisions with the source store.

### Support

Report a problem or request a feature through the Issues tab on this Actor's page. Include the run ID, target hostname, and input you used.

# Actor input Schema

## `targets` (type: `array`):

Required. Public BigCommerce storefront hostnames or URLs, such as `catalyst-demo-site.mybigcommerce.com`, `https://www.prodryers.com/`, or a pasted sitemap URL. URLs are normalized to their storefront hostname automatically.

## `maxItemsPerTarget` (type: `integer`):

Limit the number of results returned for each target. Set to `0` for every matching result. The prefilled health-check input returns one result.

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

Persistent namespace for change tracking. Keep the same value for the same targets and filters. Use another value for an independent monitor or schedule.

## `onlyChangesSince` (type: `string`):

Optional ISO 8601 timestamp such as `2026-08-01T00:00:00.000Z`. When set, the dataset contains only records detected as new, updated, or removed since that time. The first run creates the baseline.

## `requestDelayMillis` (type: `integer`):

Optional delay between product-page requests in milliseconds. Use this to honor a storefront's published crawl policy; temporary errors are retried with backoff.

## `useApifyProxy` (type: `boolean`):

BigCommerce product sitemaps and JSON-LD normally work without a proxy. Enable this only as a fallback for a storefront that blocks direct datacenter requests.

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

Optional proxy configuration used only when `useApifyProxy` is enabled.

## Actor input object example

```json
{
  "targets": [
    "https://catalyst-demo-site.mybigcommerce.com/",
    "www.prodryers.com"
  ],
  "maxItemsPerTarget": 1,
  "monitorId": "default",
  "requestDelayMillis": 0,
  "useApifyProxy": false
}
```

# 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 = {
    "targets": [
        "catalyst-demo-site.mybigcommerce.com"
    ],
    "maxItemsPerTarget": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("clintsa/bigcommerce-price-stock-delta-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 = {
    "targets": ["catalyst-demo-site.mybigcommerce.com"],
    "maxItemsPerTarget": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("clintsa/bigcommerce-price-stock-delta-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 '{
  "targets": [
    "catalyst-demo-site.mybigcommerce.com"
  ],
  "maxItemsPerTarget": 1
}' |
apify call clintsa/bigcommerce-price-stock-delta-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clintsa/bigcommerce-price-stock-delta-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/z2eoxBrmAjjilQgfk/builds/X2C6jT5BWwkpUDJLB/openapi.json