# Website Change Monitor & Structured Diff API (`blaidlink/website-change-intelligence`) Actor

Website change monitor for up to 20 authorized public pages per run. Preserve caller-isolated baselines and receive structured sentence additions, removals, hashes, and change ratios for schedules, APIs, and AI agents.

- **URL**: https://apify.com/blaidlink/website-change-intelligence.md
- **Developed by:** [Blaidlink Labs](https://apify.com/blaidlink) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 page monitoreds

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.

- **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

## Website Change Monitor & Structured Diff API

Monitor up to 20 authorized public pages per run and turn meaningful text changes into structured evidence. This Actor stores a caller-isolated baseline, removes noisy page furniture, and returns additions, removals, hashes, and change ratios for schedules, APIs, and AI agents.

### Quick start

For a zero-configuration smoke test, run the Actor with `{}`. It safely monitors `https://example.com/` and creates a caller-isolated baseline. Then replace the example URL with the authorized page you actually need to monitor.

For a durable workflow:

1. Open the public [Track SaaS pricing page changes](https://apify.com/blaidlink/website-change-intelligence/examples/track-saas-pricing-page-changes) example and choose **Try for free**.
2. Run it once to create a private baseline in your Apify account.
3. Run the same Task again after the page changes—or schedule it—to receive `changed` or `unchanged` evidence in the same output schema.

The public example monitors the authorized public `https://apify.com/pricing` page with `contentSelector` set to `main`. **Use the same saved Task for both runs** so it can find the caller-isolated baseline. The retired private Blaidlink Sites fixture is not part of the public example.

#### What the two runs look like

Run one creates evidence that the baseline exists and tells you exactly what to do next:

```json
{
  "url": "https://example.com/pricing",
  "status": "baseline",
  "changed": false,
  "previousHash": null,
  "workflowStep": "baseline-created",
  "nextAction": "Run this same saved Task again to compare, or add a schedule for recurring checks."
}
```

The next run uses the same output shape and returns either `changed` or `unchanged` evidence:

```json
{
  "url": "https://example.com/pricing",
  "status": "changed",
  "changed": true,
  "changeRatio": 0.1667,
  "added": ["The Pro plan now costs $29 per month."],
  "removed": ["The Pro plan costs $19 per month."],
  "workflowStep": "comparison-complete",
  "nextAction": "Keep this saved Task scheduled to receive the next structured comparison."
}
```

Each successful page check is one `$0.005` `page-monitored` event. The two single-page runs above therefore create `$0.01` in Blaidlink events total; Apify platform usage is separate.

### What it is for

- Competitor pricing and product-page monitoring
- Public RFP, policy, regulation, and documentation changes
- Job and careers-page monitoring
- Terms, feature, and availability changes
- Supplying structured change events to AI agents through API or MCP

The first run creates a baseline. Schedule the same Actor task to run hourly or daily; subsequent runs return `changed`, `unchanged`, `skipped`, or `error` results.

### Input

| Field | Purpose |
|---|---|
| `startUrls` | Up to 20 public HTTP(S) pages |
| `contentSelector` | CSS selector for the meaningful region, for example `main`, `#pricing`, or `.release-notes` |
| `ignoreSelectors` | Volatile regions to remove before comparison |
| `respectRobotsTxt` | Honors robots exclusions by default |
| `resetBaseline` | Replaces old snapshots without reporting a change |
| `includeUnchanged` | Emits successful unchanged checks when enabled |

### Output example

```json
{
  "url": "https://example.com/pricing",
  "status": "changed",
  "changed": true,
  "changeRatio": 0.1667,
  "added": ["The Pro plan now costs $29 per month."],
  "removed": ["The Pro plan costs $19 per month."],
  "contentHash": "...",
  "previousHash": "...",
  "checkedAt": "2026-07-18T12:00:00.000Z"
}
```

### Persistent state and privacy

Snapshots are stored in a named key-value store opened with the token of the user who starts the run. This isolates state in the caller's Apify account rather than mixing customer snapshots in the publisher's storage.

### Responsible use

Only monitor pages you are authorized to access. The Actor blocks local/private-network targets, limits redirects and response sizes, identifies itself with a dedicated user agent, and honors `robots.txt` by default. Website terms, database rights, copyright, privacy rules, and rate limits still apply to you and the target.

### Recommended schedule

Create an Actor Task with stable input and schedule it. Hourly checks work for fast-moving public pages; daily checks are more appropriate for documentation, policies, RFPs, and career pages.

### Pricing

The live price is **$0.005 per `page-monitored` event**. A bounded 20-page run therefore creates up to **$0.10 in Blaidlink events**. Apify platform usage is billed separately by Apify. The Actor stops cleanly when the customer's maximum run charge is reached.

### Output views

- **Monitoring overview** prioritizes status, page, change ratio, excerpt counts, check time, and errors.
- **Change details** prioritizes the sentence-level additions and removals used by reviewers and downstream agents.

# Actor input Schema

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

Public HTTP(S) pages you are authorized to monitor. Maximum 20 pages per run.

## `contentSelector` (type: `string`):

Optional CSS selector for the page region that matters, such as main or #pricing.

## `ignoreSelectors` (type: `array`):

Remove volatile areas such as navigation, cookie banners, timestamps, or ads before comparison.

## `respectRobotsTxt` (type: `boolean`):

Skip pages disallowed for this Actor's user agent. Keep enabled unless you have explicit authorization.

## `includeUnchanged` (type: `boolean`):

Return a result for every checked page instead of only baselines, changes, and errors.

## `resetBaseline` (type: `boolean`):

Treat the current content as a new baseline without reporting an old-to-new change.

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

Maximum network time for each request.

## `maxContentChars` (type: `integer`):

Caps stored text and comparison work to control runtime and storage costs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com/"
    }
  ],
  "contentSelector": "main",
  "ignoreSelectors": [
    "nav",
    "footer",
    "script",
    "style",
    "noscript"
  ],
  "respectRobotsTxt": true,
  "includeUnchanged": true,
  "resetBaseline": false,
  "timeoutSecs": 20,
  "maxContentChars": 100000
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        {
            "url": "https://example.com/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("blaidlink/website-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 = { "startUrls": [{ "url": "https://example.com/" }] }

# Run the Actor and wait for it to finish
run = client.actor("blaidlink/website-change-intelligence").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 '{
  "startUrls": [
    {
      "url": "https://example.com/"
    }
  ]
}' |
apify call blaidlink/website-change-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=blaidlink/website-change-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/myEdy66b5mw82Wj0k/builds/ZnCOSkdb9fKOWykfc/openapi.json