# Ecommerce Change Intelligence (`northpeak_data/ecommerce-change-intelligence`) Actor

Monitor ecommerce pages for price, stock, product and content changes. Persistent baselines turn repeated checks into structured, actionable change intelligence.

- **URL**: https://apify.com/northpeak\_data/ecommerce-change-intelligence.md
- **Developed by:** [Northpeak Data](https://apify.com/northpeak_data) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

## Ecommerce Change Intelligence

Turn ecommerce pages into a structured change feed. This Actor stores a persistent baseline for every monitored URL and reports meaningful changes in price, availability, product identity, and page content on later runs.

### Best for

- Competitor price monitoring
- Product availability tracking
- Promotion and merchandising intelligence
- Supplier and marketplace listing monitoring
- Scheduled ecommerce audits
- Feeding alerts, dashboards, BI tools, agents, Make, Zapier, or custom workflows

### What it detects

- Price changes
- In-stock / out-of-stock changes
- Sale and discount signals
- Free-shipping signals
- Product name, brand, and SKU from structured product data when available
- Page title and broader content changes
- Weighted change score from 0 to 100

### How it works

1. Add one or more product, category, or landing-page URLs.
2. The first successful check stores a baseline.
3. Run the Actor again manually or on a schedule.
4. The Actor compares the current page against the stored baseline.
5. Results are written as structured dataset items.

Persistent snapshots are kept between separate runs, so the Actor can function as a real monitoring tool rather than a one-off scraper.

### Input example

```json
{
  "urls": [
    "https://www.example.com/product/example"
  ],
  "monitorId": "competitor-a",
  "compareMode": "commerce",
  "outputMode": "all",
  "changeThreshold": 1,
  "maxPages": 10
}
```

#### Input options

- `urls` — pages to monitor.
- `monitorId` — optional namespace for separate monitoring projects. This lets the same URL have independent baselines in different projects.
- `compareMode` — `commerce`, `content`, or `all`.
- `outputMode` — `all` returns every check; `changesOnly` suppresses unchanged rows while still returning baselines, changes, and errors.
- `changeThreshold` — minimum weighted score required before a page is marked as changed.
- `maxPages` — safety limit for pages processed in a single run.

### Output

Each result can include:

- `status`: `baseline_created`, `unchanged`, `changed`, `error`, or `no_input`
- `changeType` and `changedFields`
- `changeScore`
- current and previous prices
- currencies
- availability signals
- product name, brand, and SKU
- HTTP status
- first-seen and checked timestamps
- monitoring namespace (`monitorId`)

### Recommended monitoring workflow

For ongoing monitoring, save the Actor input as an Apify Task and schedule it to run at the interval that matches your use case. Use `outputMode: changesOnly` when you want downstream automations to receive only actionable records after the initial baseline is created.

### Pricing

The planned Store model is Pay per event. The primary event is a successful ecommerce page check: a page is fetched, parsed, compared with its stored baseline, and prepared as a monitoring result.

Initial event price: **$0.005 per successful page check**.

For example, 100 successful page checks correspond to $0.50 in Actor event charges, before any platform-usage charges that may be passed through separately by Apify. Failed fetches are not intended to be billed as successful page checks.

### Verified behavior

The monitoring core has been tested with a real ecommerce product page across separate Actor runs: the first run created a baseline and a later run successfully retrieved the previous snapshot and returned `unchanged` when no relevant commerce signal had changed.

The current version also supports independent baseline namespaces through `monitorId` and selective output through `outputMode`.

### Limitations

Some websites block automated requests or render commerce data only after JavaScript execution. Those pages may return an error or limited signals in this lightweight HTTP version. Failures are reported per URL so one blocked page does not stop the rest of the run.

### Apify platform workflow

The Actor can be used with Apify Tasks, Schedules, API calls, datasets, integrations, and downstream automation tools. Limited permissions are used so the Actor remains compatible with Apify's agentic-payment eligibility requirements when Pay-per-event monetization is enabled.

### Publication status

The Actor core is verified and Store monetization configuration is prepared in the repository. Final Store publication and monetization activation are completed in the Apify Console Publication tab after billing/payout details and pricing are reviewed.

# Actor input Schema

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

Ecommerce product, category, or landing page URLs to snapshot and compare between runs.

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

Optional namespace for a monitoring project. Use a different ID for separate competitor lists or tasks that may contain the same URLs.

## `compareMode` (type: `string`):

Choose whether to focus on commercial signals, content changes, or both.

## `outputMode` (type: `string`):

Return every checked page or only baselines, detected changes, and errors.

## `changeThreshold` (type: `integer`):

Only flag a page as changed when its weighted change score reaches this value.

## `maxPages` (type: `integer`):

Safety limit for pages processed in one run.

## Actor input object example

```json
{
  "urls": [],
  "monitorId": "default",
  "compareMode": "commerce",
  "outputMode": "all",
  "changeThreshold": 1,
  "maxPages": 10
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("northpeak_data/ecommerce-change-intelligence").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("northpeak_data/ecommerce-change-intelligence").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 northpeak_data/ecommerce-change-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northpeak_data/ecommerce-change-intelligence"
        }
    }
}

```

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/1wHCpVvGj9CAX4MrB/builds/rCyxUgOkIRrFlK2lr/openapi.json