# Website Change Monitor: Detect Page Changes, Diff and Webhook (`tan-solutions/website-change-monitor`) Actor

Website change detection for pricing pages, terms, changelogs and competitor sites. Filters noise (dates, counters, rotating banners), watches a CSS selector, shows a clean diff and calls your webhook on change. Respects robots.txt. Failed checks are free.

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

## Pricing

from $15.00 / 1,000 page checkeds

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

## Website Change Monitor: Detect Page Changes, Diff and Webhook

Website change detection for pricing pages, terms, changelogs and competitor sites. Give it a list of URLs and a
schedule, and every run tells you which pages changed since the last run, with a clean diff of what was added and
removed. Noise (dates, times, counters, cache-busting tokens, rotating banners) is filtered out, you can watch just one
part of a page with a CSS selector, and your webhook is called only when something really changed. Failed checks are
never charged.

### Quick API and schedule example

Run it from code:

```bash
curl -X POST "https://api.apify.com/v2/acts/tan-solutions~website-change-monitor/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://example.com/pricing", "selector": "main"}], "stateKey": "competitor-pricing", "webhookUrl": "https://hooks.example.com/changes"}'
```

Then put the same input on a schedule: Apify Console > Schedules > Create, add this Actor with the same input, and
pick a time, for example `0 8 * * *` (every day at 08:00). Every scheduled run compares with the run before it. Keep
`stateKey` the same on every run of one watch list; a new `stateKey` starts a fresh list with its own baselines.

### What it does

- Fetches each URL over plain HTTP (no browser), extracts the main text of the page (or only the part your CSS
  selector matches) and compares it with the text saved at the last check.
- One row per URL and run, with a `status`: `changed`, `unchanged`, `new` (first check, baseline saved) or `failed`
  (with an error code and a plain message).
- For a change: a unified diff (capped at `maxDiffChars`), the added and removed text as short snippets, a
  `changeScore` from 0 to 1 (the share of the text that changed) and when the page was checked before.
- Noise filter (on by default): dates, clock times, "3 hours ago", view, like and follower counters and cache-busting
  tokens are ignored when comparing, and carousels, sliders, tickers, ads, cookie and consent banners, pop-ups and chat
  widgets are removed before the text is read. Prices, plan limits, version numbers and percentages are never treated
  as noise: a pricing page that goes from $29 to $39 reads `changed`. Add your own `ignorePatterns` (regular
  expressions) for anything else that keeps changing.
- Webhook: with `webhookUrl` set, the run sends one POST with all changed pages at the end, and only when at least one
  page changed.
- Baselines live in a named key-value store in your own account (`tansolutions-changes-<stateKey>`), so they survive between
  runs and schedules. A failed check keeps the old baseline, so the next good check still reports the change.

### Who it is for

- Marketers and founders who watch competitors' pricing pages, plans, feature lists and landing pages.
- Compliance, legal and procurement teams who track terms of service, privacy policies and supplier pages.
- Developers who follow changelogs, docs and release pages, and AI agents that need "what changed since last time".

### Quick start

1. Add pages in **Pages to watch**, one per line. To watch only part of a page, set **CSS selector** (for all pages),
   or give one page its own selector in JSON: `{"url": "https://example.com/pricing", "selector": "#plans"}`.
2. Give the list a **Monitor name** (`stateKey`), for example `competitor-pricing`.
3. Click **Start**. The first run saves the baselines (`new`); every later run reports `changed` or `unchanged`.
4. Schedule it (Console > Schedules) and add a **Webhook URL** if you want a POST on every change.

### Input

| Field (Console name) | What it does | Default |
| --- | --- | --- |
| `startUrls` (Pages to watch) | URLs, or `{"url", "selector"}` objects for a selector per page | one Apify docs page (demo) |
| `mode` (Mode) | `monitor` compares with the last check; `snapshot` only saves new baselines | `monitor` |
| `selector` (CSS selector (all pages)) | Watch only the part of each page this selector matches | whole page |
| `ignorePatterns` (Ignore patterns) | Up to 20 regular expressions; matching text is ignored when comparing | none |
| `noiseFilter` (Filter noise) | Ignore dates, times, counters, cache-busting tokens and rotating banners | on |
| `webhookUrl` (Webhook URL) | POST with the changed pages, sent only when something changed | none |
| `stateKey` (Monitor name) | Names the saved baselines (letters, digits, hyphens, at most 40) | the task ID, else `default` |
| `includeText` (Include page text) | Add the full compared text to every row | off |
| `includeLinks` (Compare link targets) | Also report a change when only a link target changed | off |
| `maxDiffChars` (Max diff length) | Diff length per row, 500 to 50,000 characters | 5,000 |
| `minRecheckSecs` (Minimum re-check interval) | A page checked more recently than this is skipped, free; 60 s to 7 days | 300 |
| `maxUrls` (Max URLs) | Pages per run, 1 to 1,000 | 100 |
| `timeoutSecs` (Timeout per page) | 5 to 120 seconds | 30 |
| `maxConcurrency` (Parallel pages) | Pages fetched at once, 1 to 20 | 5 |
| `proxyConfiguration` (Proxy) | Optional Apify Proxy | off |

```json
{
  "startUrls": [
    { "url": "https://example.com/pricing", "selector": "#plans" },
    { "url": "https://example.com/terms" }
  ],
  "stateKey": "competitor-pricing",
  "ignorePatterns": ["Order #\\d+"],
  "webhookUrl": "https://hooks.example.com/changes"
}
```

**Opening hours and timetables:** the noise filter ignores clock times ("9:00") and weekday names in dates. To watch a
page where those are the content (opening hours, timetables, event times), set `noiseFilter: false` and use
`ignorePatterns` for the parts that really are noise.

### Output example

One dataset item per URL and run. Views: Overview and Diffs. A changed pricing page:

```json
{
  "url": "https://example.com/pricing", "finalUrl": "https://example.com/pricing", "selector": "#plans",
  "status": "changed", "title": "Pricing", "changeScore": 0.0412,
  "diff": "@@ -3,3 +3,3 @@\n ## Pro\n-$29 per month\n+$35 per month\n Unlimited projects",
  "diffTruncated": false, "addedText": ["$35 per month"], "removedText": ["$29 per month"],
  "addedLines": 1, "removedLines": 1, "lineCount": 24, "contentHash": "5c1f0e9a2b7d4c31",
  "text": null, "httpStatus": 200,
  "checkedAt": "2026-11-14T08:00:12.511Z", "previousCheckedAt": "2026-11-13T08:00:10.204Z",
  "note": null, "error": null
}
```

A failed row has `status: "failed"` and an `error`, for example
`{"code": "SELECTOR_NOT_FOUND", "message": "the CSS selector \"#plans\" matched nothing on the page (the page layout may have changed)"}`.
Error codes: `ROBOTS_DISALLOWED`, `BLOCKED` (CAPTCHA or bot wall), `HTTP_ERROR` (4xx/5xx), `TIMEOUT`, `DNS_ERROR`,
`CONNECTION_FAILED`, `TOO_MANY_REDIRECTS`, `INVALID_URL`, `URL_NOT_ALLOWED`, `UNSUPPORTED_CONTENT_TYPE`,
`CONTENT_TOO_LARGE`, `EMPTY_CONTENT`, `SELECTOR_NOT_FOUND`, `RATE_LIMITED` (checked again too soon, or the site keeps
answering 429), `BLOCKED_BACKOFF` (the page blocked an earlier check: see below), `MAX_PAGES_REACHED` (over `maxUrls`), `INVALID_INPUT` (a bad URL, or the same URL and selector
twice in one input: it is checked once), `INTERNAL_ERROR`.
If a page's HTML is too broken to convert, the row still succeeds with the page's plain text and `parseFallback: true`.

The webhook body (one POST per run, only if a page changed; at most 100 changes, each diff cut at 2,000 characters;
the full diffs are in the dataset):

```json
{
  "event": "website.changed", "stateKey": "competitor-pricing", "runId": "a1B2c3D4e5F6g7H8i",
  "checkedAt": "2026-11-14T08:00:15.002Z", "changedCount": 1, "truncated": false,
  "changes": [{ "url": "https://example.com/pricing", "finalUrl": "https://example.com/pricing", "selector": "#plans",
    "title": "Pricing", "changeScore": 0.0412, "diff": "...", "addedText": ["$35 per month"],
    "removedText": ["$29 per month"], "checkedAt": "2026-11-14T08:00:12.511Z",
    "previousCheckedAt": "2026-11-13T08:00:10.204Z" }]
}
```

### Pricing

You pay per page check (the `page-check` event): every `changed`, `unchanged` or `new` row, including the first check
that saves a baseline and every check in snapshot mode. A change costs nothing extra, and so does the webhook.

| Apify plan | Price per 1,000 page checks |
| --- | --- |
| Free | $40 |
| Bronze | $28 |
| Silver | $20 |
| Gold | $15 |

TODO-CEO: these are proposed prices, not yet confirmed.

Free: every `failed` row (robots.txt, bot walls, 4xx/5xx, timeouts, selector misses, pages checked again too soon,
duplicates, URLs over `maxUrls`). A failed or unpaid check keeps the old baseline. If your spending limit is reached,
the run checks only the pages it can still pay for, then stops cleanly and says so; no saved baseline is lost. Apify's standard Actor start event is charged when a run
starts, at the platform's default price.

### Limits

- Plain HTTP only, no browser: pages that build their content with JavaScript show little or no text. Pick
  server-rendered pages, or a selector that is in the page's HTML.
- At most 1,000 URLs per run (default 100), and one check per URL every 60 seconds at the fastest (default 300 s).
- Politeness: at most 2 requests at once and at least 1 second between requests to one site; `Crawl-delay` in
  robots.txt is honoured (a site asking for more than 30 s is skipped as `RATE_LIMITED`).
- It obeys robots.txt (the `TanForgeBot` token, then `*`), never logs in and stops at CAPTCHAs and bot walls
  (`BLOCKED`). It uses no proxy unless you turn one on, and never rotates addresses to get past a block.
- Pages behind bot walls or robots refusals fail free; a browser fallback is not in v1.
- It identifies itself as `TanForgeBot/1.0 (+https://apify.com/tan-solutions)`. Site owners can allow or block it in
  robots.txt with the `TanForgeBot` token.
- Alerts go to your webhook (or Apify's own run notifications and integrations); there is no built-in email.
- Pages over 5 million characters of HTML, or over 2 million characters of markup outside scripts and styles, fail free
  with `CONTENT_TOO_LARGE`.

### FAQ

**Why did a page read `unchanged` when its date changed?** That is the noise filter at work: dates, times and counters
are ignored. Turn `noiseFilter` off to compare the raw text.

**My selector no longer matches. What happens?** The row fails free with `SELECTOR_NOT_FOUND` and the old baseline is
kept; fix the selector and the next run compares as before.

**Can I check a page every minute?** The fastest is once every 60 seconds per page (`minRecheckSecs`); a re-check
inside that window is a free `failed` row with `RATE_LIMITED`.

**A site blocked the check. What then?** A bot wall or CAPTCHA, HTTP 401, 403 or 429, or a robots.txt disallow is a
free `failed` row, and that page is not requested again for 24 hours (or `minRecheckSecs`, if longer). Runs in
between list it as a free `failed` row with `BLOCKED_BACKOFF` and send no request; the baseline is kept. Network
errors and 5xx answers are simply tried again on the next run.

**I changed the selector or the ignore patterns. Do I get a fake change?** No: that page starts a new baseline (`new`).

**Can I call it from an AI agent, n8n, Make or Zapier?** Yes, through the Apify API, SDKs, MCP or those
integrations: pass `startUrls` and `stateKey`, read the dataset items, or receive the webhook.

### Related tools by Tan Solutions

- [URL to Markdown](https://apify.com/tan-solutions/url-to-markdown): turn any web page into clean Markdown for LLMs,
  RAG and AI agents.
- [SEO Audit](https://apify.com/tan-solutions/seo-audit): check a page or site for SEO problems.
- [Domain Intelligence](https://apify.com/tan-solutions/domain-intel): DNS, WHOIS/RDAP, SSL and tech stack of a
  company's website domain.
- [Shopify Store Products](https://apify.com/tan-solutions/shopify-products): prices, variants and stock of the
  Shopify stores you name.

### Your responsibilities

You are responsible for the URLs you submit and for lawful use of the text you get back (copyright, the site's terms,
any restrictions the site states, and privacy law for any personal data on the page). The Actor obeys robots.txt, does
not log in and stops at CAPTCHAs and bot walls. 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 any website you monitor. All names belong to their owners.

Made by Tan Solutions.

# Actor input Schema

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

URLs to check, with http:// or https://. Plain URLs, or objects like {"url": "https://example.com/pricing", "selector": "#plans"} to watch only part of a page. Left out, the run checks one Apify docs page as a demo.

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

Monitor compares every page with its last check. Snapshot only saves the current pages as the new baseline.

## `selector` (type: `string`):

Watch only the elements this CSS selector matches, for example .pricing-table. A selector given with a URL wins. Empty = the whole page.

## `ignorePatterns` (type: `array`):

Regular expressions for text to ignore, for example: Tip of the day: .\* (case-insensitive, at most 20).

## `noiseFilter` (type: `boolean`):

Ignore dates, times, '3 hours ago', view and like counters, cache-busting tokens and rotating banners. Prices, plan limits, versions and percentages are always compared.

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

Called once per run with a JSON POST listing the changed pages, only when something changed.

## `stateKey` (type: `string`):

Runs with the same name compare with each other. Default: each saved task keeps its own history. Letters, digits and hyphens.

## `includeText` (type: `boolean`):

Add the full extracted text of each page to its row.

## `includeLinks` (type: `boolean`):

Also report changed link URLs, not only the link text.

## `maxDiffChars` (type: `integer`):

Characters of unified diff per page; longer diffs are cut and marked.

## `minRecheckSecs` (type: `integer`):

A page checked more recently than this is skipped, free. Protects the sites you watch. At least 60.

## `maxUrls` (type: `integer`):

URLs past this number are listed as not checked (free). Hard limit 1000 per run.

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

How long one page may take; a slower page fails (not charged).

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

Pages fetched at once; never more than 2 per site.

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

Optional. One proxy for the whole run, never used to get past a bot wall.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "mode": "monitor",
  "noiseFilter": true,
  "includeText": false,
  "includeLinks": false,
  "maxDiffChars": 5000,
  "minRecheckSecs": 300,
  "maxUrls": 100,
  "timeoutSecs": 30,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per URL: changed, unchanged, new or failed, with the change score and the added and removed text.

## `diffs` (type: `string`):

The unified diff of every page against its previous check.

# 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"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tan-solutions/website-change-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/Fxaxl7aflxFXQCEw9/builds/PNq5vs8PdwbHbJHiL/openapi.json
