Website Change Monitor

What does Website Change Monitor do?

Website Change Monitor tracks web page content changes automatically. Give it URLs to watch, and it compares each page against its previous snapshot to detect text additions, removals, and modifications. It outputs structured diff reports with change percentages, severity scoring, and line-by-line summaries — ready for alerts, dashboards, or automation workflows.

Who is it for?

• 📊 Competitive intelligence teams — monitoring competitor websites for content and pricing changes
• 🛡️ Brand protection teams — detecting unauthorized use of brand assets on web pages
• 📋 Compliance officers — tracking regulatory website updates for policy changes
• 💼 Procurement teams — monitoring vendor pages for pricing and availability updates
• 🔍 SEO specialists — tracking competitor content updates and site structure changes

Why use Website Change Monitor?

• Targeted monitoring — use CSS selectors to watch specific page sections (prices, stock status, headlines)
• Smart diffing — compares normalized text or HTML with line-level granularity
• Severity scoring — automatic low/medium/high classification based on change magnitude
• Noise filtering — regex ignore patterns strip timestamps, session tokens, and ads before comparison
• Persistent snapshots — stores previous versions in Key-Value Store across scheduled runs
• Workflow-ready — structured JSON output integrates with Zapier, Make, n8n, and Slack via webhooks

What data can you extract?

Field	Example
url	https://news.ycombinator.com
status	changed, unchanged, new, or error
changePercent	42
severity	high
addedLines	15
removedLines	8
diffSummary	Line-by-line diff (first 10 changes)
previousSnapshotAt	2026-02-27T12:00:00.000Z
checkedAt	2026-02-28T12:00:00.000Z

How much does it cost to monitor websites for changes?

Website Change Monitor uses pay-per-event pricing — you only pay for what you check.

Event	What triggers it	FREE tier	GOLD+ tier
start	Each actor run	$0.035	$0.025
page-checked	Each URL checked (no change)	$0.001	$0.0007
change-detected	Each URL where a change is found	$0.003	$0.002

Real-world cost examples

Scenario	URLs	Cost/run (FREE)	Monthly (daily schedule)
Monitor 1 page	1	$0.036–$0.038	~$1.14
Watch 10 pages	10	$0.045–$0.065	~$1.65
Track 50 pages	50	$0.085–$0.185	~$4.05

Platform compute costs (memory + time) are billed separately by Apify at standard rates.

How to monitor websites for changes

1. Add URLs — enter the web pages you want to watch.
2. Set a CSS selector (optional) — target a specific part of the page like .price, #headline, or article.
3. Choose content mode — text for visible content only (recommended) or html for structure changes.
4. Add ignore patterns (optional) — regex patterns to strip dynamic content before comparison.
5. Schedule the actor — set up recurring runs (hourly, daily) to detect changes over time.
6. Get results — export changes as JSON/CSV or trigger webhooks for real-time alerts.

Example input

{
  "urls": [
    "https://news.ycombinator.com",
    "https://example.com/pricing"
  ],
  "cssSelector": "",
  "mode": "text",
  "ignorePatterns": ["\\d+ minutes ago", "\\d+ points"],
  "notifyOnFirstRun": false
}

Input parameters

Parameter	Type	Default	Description
urls	string[]	required	Web page URLs to check for changes. Each URL is fetched and compared against its previous snapshot.
cssSelector	string	""	CSS selector to monitor only a specific part of the page. When empty, the full page body text is monitored.
mode	string	text	Content comparison mode: text compares visible text only (recommended), html compares raw HTML structure.
ignorePatterns	string[]	[]	Regex patterns to strip before comparison. Use to filter timestamps, session tokens, or dynamic ads.
notifyOnFirstRun	boolean	false	When enabled, first-run results (no previous snapshot) are included in the dataset as status new.
proxyConfiguration	object	platform default	Apify proxy configuration for fetching pages.

Output example

{
  "url": "https://news.ycombinator.com",
  "status": "changed",
  "changePercent": 42,
  "severity": "high",
  "addedLines": 15,
  "removedLines": 8,
  "diffSummary": "+ New story about AI research\n+ 342 points by user123\n- Old story about web frameworks\n- 128 points by user456",
  "previousSnapshotAt": "2026-02-27T12:00:00.000Z",
  "checkedAt": "2026-02-28T12:00:00.000Z"
}

Tips for best results

• Use CSS selectors to focus on the content you care about — monitoring the full page catches irrelevant changes like ads and timestamps.
• Schedule runs for regular monitoring — set up hourly or daily schedules from the Apify console.
• Add ignore patterns for dynamic content like "\\d+ minutes ago" or "session=[a-f0-9]+" to reduce false positives.
• Start with text mode — it's more resilient to minor HTML restructuring that doesn't affect visible content.
• Use notifyOnFirstRun: true if you want the first snapshot to appear in your dataset for debugging.
• Connect webhooks for real-time alerts — trigger Slack messages, emails, or workflow automations when changes are detected.
• Monitor competitor pricing — use a selector like .price or [data-price] to track price changes.
• Track regulatory pages — monitor terms of service, privacy policies, or compliance documents for legal teams.

cURL

curl -X POST "https://api.apify.com/v2/acts/automation-lab~website-change-monitor/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://example.com/pricing"],
    "cssSelector": ".price",
    "mode": "text"
  }'

Use with Claude AI (MCP)

This actor is available as a tool in Claude AI through the Model Context Protocol (MCP). Add it to Claude Desktop, Cursor, Windsurf, or any MCP-compatible client to let Claude monitor web pages for changes directly in your conversation.

Setup

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-apify"],
      "env": {
        "APIFY_TOKEN": "your-apify-api-token"
      }
    }
  }
}

Claude Code CLI:

$claude mcp add apify -- npx -y @anthropic-ai/mcp-apify

Example prompts

• "Monitor this webpage for changes and alert me: https://example.com/pricing"
• "Check if this product page has been updated since yesterday"
• "Set up monitoring for these competitor pricing pages and show what changed"

Integrations

Connect Website Change Monitor with any cloud service via Apify integrations. Send change alerts to Slack, trigger Make/n8n/Zapier workflows, push to Google Sheets, or use webhooks for custom automation.

Using the Apify API

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/website-change-monitor').call({
  urls: ['https://example.com/pricing'],
  cssSelector: '.price',
  mode: 'text',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/website-change-monitor').call(run_input={
    'urls': ['https://example.com/pricing'],
    'cssSelector': '.price',
    'mode': 'text',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Legality

This tool analyzes publicly accessible web content. Automated analysis of public web resources is standard practice in SEO and web development. Always respect robots.txt directives and rate limits when analyzing third-party websites. For personal data processing, ensure compliance with applicable privacy regulations.

FAQ

How does it detect changes? The actor fetches each URL, extracts content (text or HTML), and compares it against the previous snapshot stored in Apify Key-Value Store. It uses line-level diffing to identify additions and removals.

What happens on the first run? The first run saves a baseline snapshot for each URL. No changes are reported unless you enable notifyOnFirstRun. Subsequent runs compare against this baseline.

Can I monitor specific parts of a page? Yes. Use the cssSelector field to target elements like #price, .article-body, or table.results. Only the matched content is compared.

How should I schedule it? Use Apify's built-in scheduling to run the actor hourly, daily, or at custom intervals. Each run compares against the most recent snapshot.

Does it work with JavaScript-rendered pages? The current version uses HTTP fetching, which works for server-rendered pages. For heavily JavaScript-dependent sites, the content may be limited to what's in the initial HTML response.

How do ignore patterns work? Ignore patterns are JavaScript regular expressions applied to the content before comparison. For example, "\\d+ hours ago" removes all timestamps like "2 hours ago" before diffing.

What does the severity score mean? Severity is based on the percentage of lines changed: low (≤5%), medium (6–25%), high (>25%). new means it's the first snapshot. none means no change.

Can I get alerts when something changes? Yes. Connect the actor to a webhook, Slack, email via Zapier/Make/n8n, or use the Apify API to poll for results with status: "changed".

Every run shows changes even though the page content has not really changed. How do I fix this? This is usually caused by dynamic content like timestamps, session tokens, or ad rotations. Add regex patterns to the ignorePatterns field to strip these elements before comparison. For example, "\\d+ minutes ago" filters out relative timestamps, and "session=[a-f0-9]+" removes session tokens from the text.

The first run does not report any changes. Is this expected? Yes. The first run creates a baseline snapshot and has nothing to compare against, so no changes are reported. Set notifyOnFirstRun: true if you want the first snapshot to appear in the dataset for debugging purposes. Subsequent runs will compare against this baseline.

Other automation tools on Apify

• Website Uptime Checker — check if websites are up and measure response times
• Website Health Report — comprehensive website health audit with scoring
• Website Performance Checker — measure TTFB, page size, and compression