Website HTML & Text Change Monitor

Website HTML & Text Change Monitor performs website change monitoring for supplied public webpages. It fetches server-rendered HTML, creates versioned HTML and normalized-text snapshots, compares each page with its saved baseline, and exports machine-readable additions, removals, changed fragments, hashes, timestamps, and threshold decisions.

Use it for recurring documentation checks, policy and compliance monitoring, release intelligence, competitor-page tracking, or any workflow that needs structured content differences instead of screenshots.

What does Website HTML & Text Change Monitor do?

For every supplied URL, the Actor:

1. Fetches anonymous public HTML with bounded timeouts and retries.
2. Optionally focuses on one CSS-selected content region.
3. Removes scripts, styles, configured noise selectors, and matching text patterns.
4. Creates normalized HTML and text snapshots.
5. Compares the current snapshot with the previous successful snapshot.
6. Calculates hashes, changed-character percentage, and threshold status.
7. Emits additions, removals, and typed HTML/text change fragments.
8. Saves the current successful snapshot as the next baseline when enabled.

The first successful check initializes a baseline. Later runs using the same Actor Task or monitorId produce actual differences.

Who is this website change monitor for?

• Compliance teams tracking public terms, policies, standards, and disclosures.
• Developer-relations teams watching documentation and release pages.
• SEO and content teams auditing unexpected page copy or markup changes.
• Competitive-intelligence teams monitoring public pricing and feature pages.
• QA engineers checking server-rendered production content after deployments.
• Automation developers feeding structured change events to webhooks, Make, Zapier, n8n, Slack, or databases.

Choose this Actor when HTML structure and extracted text matter. For pixel-level layout, style, or rendered JavaScript changes, use Website Visual Change Monitor.

Why use structured HTML and text snapshots?

A screenshot can show that pixels moved, but it is harder to query or route through an automation. This Actor returns the source content and typed differences directly.

Useful differentiators include:

• separate HTML and text hashes;
• raw normalized snapshot values in each successful dataset row;
• persistent baseline metadata with timestamps and lengths;
• text additions and removals ready for alerts;
• HTML/text change fragments with added or removed type;
• a configurable percentage threshold;
• CSS region targeting and noise removal;
• direct HTTP execution without browser overhead;
• optional, user-controlled Apify Proxy support with no automatic paid fallback.

What data does the Actor return?

Field	Meaning
url, finalUrl	Requested normalized URL and final URL after redirects
status	success or error for this webpage
title	Current HTML document title
checkedAt	ISO timestamp for the check
monitorId	Snapshot namespace supplied in input
compareMode	html, text, or both
baselineInitialized	true when no prior snapshot existed
baselineUpdated	Whether current content became the next baseline
previousSnapshot	Prior hashes, timestamp, and content lengths
currentSnapshot	Current hashes, timestamp, and content lengths
html, text	Current normalized HTML and extracted text
htmlChanged, textChanged	Hash-level change flags
changePercent	Changed-character percentage for the selected mode
changeThresholdPercent	Configured alert threshold
thresholdExceeded	Machine-readable alert decision
addedText, removedText	Up to 50 line-level text additions and removals
changedSections	Up to 100 typed HTML/text fragments
error	Actionable per-URL error when a page fails

Error rows are not charged as item events. If every URL fails, the run fails after preserving those diagnostic rows.

How to monitor a webpage for changes

1. Open the Actor in Apify Console.
2. Add one or more anonymously reachable public URLs.
3. Enter a stable, unique monitorId.
4. Choose HTML, text, or combined comparison.
5. Optionally set contentSelector, noise filters, and an alert threshold.
6. Run once to establish the baseline.
7. Save the input as an Actor Task and schedule recurring runs.
8. Read thresholdExceeded, addedText, and removedText in the dataset or a webhook integration.

A saved Actor Task is recommended for recurring work because its task ID automatically isolates the baseline namespace.

Input parameters

Parameter	Required	Default	Description
startUrls	Yes	Apify Actor docs	One to 100 public HTTP/HTTPS webpages
monitorId	Yes	apify-actors-docs-monitor	Stable unique snapshot namespace
compareMode	No	both	Compare html, text, or both
contentSelector	No	—	Limit capture to the first CSS match
ignoreSelectors	No	scripts/styles	Remove dynamic or irrelevant elements
ignoreTextPatterns	No	[]	Remove matching JavaScript regular expressions
changeThresholdPercent	No	1	Percentage required for thresholdExceeded=true
updateBaseline	No	true	Save successful current content for the next run
resetBaseline	No	false	Ignore and replace the saved baseline
maxItems	No	20	Maximum URLs processed, up to 100
maxContentBytes	No	2000000	Reject unexpectedly large HTML responses
requestTimeoutSecs	No	30	Per-request timeout from 5 to 120 seconds
maxRequestRetries	No	2	Temporary-error retry limit from 0 to 5
proxyConfiguration	No	direct	Optional Apify Proxy configuration

Only enable a proxy when direct anonymous access is insufficient. Proxy transfer may add platform usage cost.

Example input

{
  "startUrls": [
    { "url": "https://docs.apify.com/platform/actors" }
  ],
  "monitorId": "apify-actors-docs-monitor",
  "compareMode": "both",
  "contentSelector": "main",
  "ignoreSelectors": ["script", "style", "noscript"],
  "changeThresholdPercent": 1,
  "updateBaseline": true,
  "maxItems": 1
}

The first run initializes the snapshot. Run the same input again after the source changes to receive additions and removals.

Example output

This abbreviated record reflects the current Actor contract:

{
  "url": "https://docs.apify.com/platform/actors",
  "finalUrl": "https://docs.apify.com/platform/actors",
  "status": "success",
  "title": "Actors | Platform | Apify Documentation",
  "checkedAt": "2026-08-19T06:22:11.713Z",
  "monitorId": "apify-actors-docs-monitor",
  "compareMode": "both",
  "baselineInitialized": false,
  "baselineUpdated": true,
  "htmlChanged": false,
  "textChanged": false,
  "changePercent": 0,
  "changeThresholdPercent": 1,
  "thresholdExceeded": false,
  "addedText": [],
  "removedText": [],
  "changedSections": [],
  "currentSnapshot": {
    "htmlHash": "a32bb16aa68d83ba70302d1617bec10948df1dfe85c3617f7089680a71a022cb",
    "textHash": "f5328eecc7dd817acb0f4d6ff797b99b8a15a8f017ee9ca8ac7c56554939e592",
    "htmlLength": 27369,
    "textLength": 2509
  }
}

Successful rows also contain the full normalized html and text snapshot values.

How thresholds and baselines work

changePercent measures added and removed characters against the combined previous/current size for the selected comparison mode. It is not a semantic importance score.

• A new baseline always reports changePercent: 0 and thresholdExceeded: false.
• htmlChanged and textChanged compare SHA-256 hashes independently.
• thresholdExceeded becomes true when changePercent reaches the configured threshold.
• Set updateBaseline: false to keep comparing against one fixed snapshot.
• Set resetBaseline: true after intentionally changing selectors or normalization rules.

Changing compareMode, contentSelector, or ignore rules can create a large one-time difference. Reset the baseline when making those configuration changes.

How much does it cost to monitor website changes?

The Actor uses pay-per-event pricing:

Event	Price	Charged when
Start	$0.005	Once when a run begins
Item, BRONZE tier	$0.052	For each successful webpage snapshot

At the BRONZE tier, 1 successful page costs $0.057, 10 pages cost $0.525, and 100 pages cost $5.205 before any optional proxy platform usage. The six subscription tiers decrease from $0.0598 per item on FREE to $0.01456 on DIAMOND; Apify Console applies the customer’s active tier. Failed URL rows have no item event charge.

Scheduling website change alerts

Save a tested input as an Actor Task, then connect it to an Apify Schedule. A common workflow is:

1. Run hourly, daily, or weekly.
2. Filter dataset rows where thresholdExceeded is true.
3. Send addedText, removedText, and the URL to Slack or email.
4. Store snapshot hashes in a data warehouse for audit history.

The Actor reports decisions; it does not itself send email or Slack notifications. Use Apify webhooks or an integration for delivery.

Integration ideas

• Make or Zapier: trigger a notification when a dataset row exceeds its threshold.
• n8n: branch by htmlChanged versus textChanged and route markup-only changes separately.
• Google Sheets: append timestamp, URL, hashes, and threshold status for an audit ledger.
• Slack: post concise additions/removals for documentation or policy owners.
• Data warehouse: store snapshot hashes and content lengths for longitudinal analysis.
• CI/CD: run after deployment and fail a downstream check on unexpected production content changes.

API usage

Run the Actor synchronously from Apify clients or start it through the REST API. Reuse the same saved Actor Task for persistent scheduled baselines.

Run with the Apify JavaScript client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/website-html-text-change-monitor').call({
  startUrls: [{ url: 'https://docs.apify.com/platform/actors' }],
  monitorId: 'apify-actors-docs-monitor',
  compareMode: 'both',
  changeThresholdPercent: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Run with Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/website-html-text-change-monitor').call(run_input={
    'startUrls': [{'url': 'https://www.w3.org/TR/WCAG22/'}],
    'monitorId': 'wcag-22-monitor',
    'compareMode': 'text',
    'contentSelector': '#abstract',
    'changeThresholdPercent': 0.1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
for item in items:
    print(item['url'], item.get('thresholdExceeded'))

Run with cURL

curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~website-html-text-change-monitor/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url":"https://docs.apify.com/platform/actors"}],
    "monitorId": "apify-actors-docs-monitor",
    "compareMode": "both",
    "changeThresholdPercent": 1
  }'

Never commit an API token to source control. Use environment variables or your platform secret manager.

Use Website HTML & Text Change Monitor through MCP

Add the Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/website-html-text-change-monitor"

For Claude Desktop, Cursor, VS Code, or another MCP client:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/website-html-text-change-monitor"
    }
  }
}

Example prompts:

• “Initialize a text baseline for the W3C WCAG abstract.”
• “Check these documentation URLs and list only threshold-exceeding changes.”
• “Show additions and removals from my scheduled pricing-page monitor.”

Tips for reliable page change monitoring

• Target the smallest stable region with contentSelector.
• Remove clocks, randomized IDs, ads, and rotating widgets with ignore rules.
• Prefer one stable Actor Task for each monitoring workflow.
• Use a unique monitorId for direct Actor runs.
• Reset the baseline after changing selectors or normalization settings.
• Keep maxContentBytes conservative to catch accidental downloads or oversized pages.
• Start with direct requests and enable a proxy only when evidence requires it.
• Use a nonzero threshold when sources make harmless small changes.

Limitations

• The Actor processes server-rendered HTML and does not execute page JavaScript.
• Login-only, private, CAPTCHA, and challenge pages are unsupported.
• It does not crawl links; only supplied URLs are checked.
• Highly personalized or A/B-tested content can produce different snapshots.
• Normalization cannot infer whether a textual change is legally or commercially important.
• changedSections and text arrays are capped to keep records usable; full current HTML and text remain available.
• Named snapshot state is intended for unique monitor IDs or Actor Tasks; do not reuse one monitor ID for unrelated workflows.
• The Actor emits structured decisions but does not send alerts itself.

Troubleshooting

The first run reports no changes

That is expected. It initializes the baseline. Run the same task again after the page changes.

A selector matched no content

Verify contentSelector against the server-rendered response, not only the browser DOM. Remove it to inspect the full snapshot.

A page returns a challenge or HTTP error

Confirm it is anonymously accessible. If direct access is geographically restricted, try an appropriate Apify Proxy country. JavaScript-only challenges may require a browser-based Actor instead.

Every run reports small changes

Add stable ignoreSelectors or narrowly scoped ignoreTextPatterns, then reset the baseline. Avoid broad expressions that remove meaningful content.

The run fails after writing error rows

When all requested URLs fail, the Actor deliberately exits non-zero so schedules and monitoring systems do not mistake failure for “no changes.” Inspect each row’s error field.

Responsible use and legality

Monitor only public pages you are authorized to access. Respect website terms, robots guidance, rate limits, intellectual-property rights, privacy obligations, and applicable laws. Do not use this Actor to bypass authentication, access controls, CAPTCHAs, or technical restrictions. Choose a reasonable schedule and avoid excessive requests to third-party sites.

FAQ

Does the Actor preserve raw HTML?

It returns normalized HTML after removing scripts, styles, configured ignored elements, comments, and redundant whitespace. This makes structural changes easier to compare but is not a byte-for-byte archive of the response.

Can it detect text changes without markup noise?

Yes. Use compareMode: "text"; the Actor extracts normalized semantic text lines and reports additions and removals.

Can I monitor multiple pages?

Yes. Supply up to 100 URLs and use maxItems to cap a run.

Can I keep a fixed baseline?

Yes. Initialize once, then set updateBaseline: false for subsequent checks.

Does it work with scheduled Actor Tasks?

Yes. Tasks are the recommended recurring workflow and receive task-scoped baseline isolation.

Does it send a website change alert?

It emits webhook-ready threshold decisions and diffs. Connect an Apify webhook, Make, Zapier, n8n, or your own integration to send notifications.

Related Automation Lab Actors

• Website Visual Change Monitor — browser screenshots, pixel percentages, and visual diff overlays.
• Webpage Structured Data Monitor — track JSON-LD and structured metadata changes.
• Lighthouse Website Audit — monitor performance, accessibility, best-practice, and SEO audit results.
• Wayback Machine Checker — inspect public Internet Archive snapshot history.