Webpage Field Change Detection Scraper

Webpage field change detection for spreadsheet monitoring: extract named CSS text or attribute fields from public static HTML URLs, compare your supplied previous values, and export current values plus changed-field old/new pairs with observation timestamps.

For operations analysts checking a handful of prices, headings, availability labels or links twice daily. Unlike whole-page hashes or line diffs, the result keeps your field names and excludes unchanged fields from changes. It does not keep snapshots or send alerts automatically.

What it does

• Fetches the supplied anonymous public HTTP(S) pages, in order.
• Extracts the first matching element for each named CSS selector.
• Reads descendant text or an optional raw HTML attribute.
• Compares only keys you supply in each page's previousValues.
• Returns one page observation in the default dataset, including unchanged observations.

No JavaScript rendering, login, CAPTCHA handling, XPath, crawling or link discovery is included. Attribute links remain raw rather than resolved URLs.

Who is it for?

Operations analysts, spreadsheet owners and data engineers comparing configured public-page fields against their own prior observations.

Why use this Actor?

Keep comparison state in your spreadsheet or pipeline rather than hidden Actor storage. Use the same field definitions on every page and pass a different baseline per URL. Field-level changes let you distinguish a changed price from an unrelated footer edit. Missing fields are visible as null, not silently dropped.

Getting started

1. Run the prefilled Books to Scrape demonstration input.
2. Replace the URL with a public static HTML page you are permitted to fetch.
3. Define up to 30 named CSS fields; inspect page source, not just rendered browser content.
4. On a first observation, omit previous values to establish a baseline.
5. Export currentValues and pass them back in previousValues next time.
6. Filter hasChanges or inspect changes to update your spreadsheet.

Input parameters

Parameter	Meaning
pages	1–1000 unique objects with url and optional previousValues.
fields	1–30 shared definitions: name, CSS selector, optional attribute.
maxItems	Global page observation cap, default 10, range 1–1000. Only the first supplied pages are fetched.

{
  "pages": [{
    "url": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
    "previousValues": {"heading": "Old heading", "price": "£51.77"}
  }],
  "fields": [
    {"name": "heading", "selector": "h1"},
    {"name": "price", "selector": ".product_main .price_color"},
    {"name": "homeLink", "selector": ".breadcrumb a", "attribute": "href"}
  ],
  "maxItems": 1
}

Field names are case-sensitive safe identifiers starting with a letter, at most 64 characters. Duplicate names and unknown baseline keys are rejected. Duplicate canonical URLs (after removing fragments) are rejected to avoid conflicting baselines. Zero/unlimited limits are unsupported.

How webpage field change detection compares values

Text and attributes are trimmed and all whitespace runs collapse to a single space. Equality is then exact and case-sensitive; there is no numeric, currency or fuzzy matching. HTML entities are decoded by the parser. The first matching element is used; its descendant text is included.

An omitted baseline key establishes a baseline and is listed in baselineFields, not in changes. An explicit null baseline means the field was previously missing. A missing current element or attribute is null, distinct from an empty string. Other values must be strings. Each value is bounded to 10000 characters; oversized fields fail instead of truncating.

Output fields

Field	Meaning
url	Canonical input URL associated with this baseline.
finalUrl	Public destination after redirects.
observedAt	UTC ISO timestamp after fetching.
currentValues	Every named field's string or null.
changes	Changed fields only, each with oldValue and newValue.
changedFields	Names in changes.
missingFields	Fields with no matching element or attribute.
baselineFields	Fields without supplied previous values.
hasChanges	True when at least one supplied baseline differs.

Output example

From the demonstrated product-page input (the observation time varies):

{
  "url": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
  "finalUrl": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
  "observedAt": "2026-10-12T14:14:01.130Z",
  "currentValues": {"heading": "A Light in the Attic", "price": "£51.77", "homeLink": "../../index.html"},
  "changes": {"heading": {"oldValue": "Old heading", "newValue": "A Light in the Attic"}},
  "changedFields": ["heading"],
  "missingFields": [],
  "baselineFields": ["homeLink"],
  "hasChanges": true
}

The unchanged price is absent from changes. The home link has no baseline, so it is not reported as a change. Export through Apify's dataset tools as JSON, CSV or Excel; nested objects may need flattening downstream.

How much does it cost to compare fields on webpages?

Pay-per-event billing has a one-time start fee of $0.005 and one item event per successfully stored page observation, whether changed, unchanged or first baseline. There is no additional per-field or change event. Failed pages do not produce an item charge; a run that starts fetching can still incur its start fee.

BRONZE pricing is $0.0028 per page observation. Estimated event totals including one start: one page $0.0078, ten pages $0.033, 100 pages $0.285. FREE is $0.00322, SILVER $0.002184, and GOLD/PLATINUM/DIAMOND $0.00168 per page. Spend tiers follow your qualifying aggregate monthly Apify Store spend, not volume within this Actor. Consult the active Pricing tab for plan-specific rates. Platform usage is included in the event tariff, not an extra Actor event. Your integrations can have separate costs.

Limits and failure behavior

Requests are sequential. Each attempt has a 20-second timeout, at most five redirects and at most 2 MiB of decompressed UTF-8 HTML. Transient network faults, 429 and selected 5xx responses get up to two retries with bounded backoff. No proxy or browser fallback is enabled.

HTTP errors, non-HTML responses, private destinations and pages where every configured field is missing fail the run. Earlier rows are partial, not proof that all requested pages were checked. The Actor does not treat arbitrary challenge pages as good observations; use precise selectors and review missing fields. A page with some missing fields still returns an observation and can report removals.

No 100000-URLs/hour guarantee is made. maxItems is a page cap, not a throughput guarantee; runtime and spending limits can stop a run earlier. Increase timeout when supplying many pages, and keep target load reasonable. Concurrent mutation during observation is not a transactional snapshot.

Integrations

For Google Sheets or Excel, export current values and use them as the next baseline. A Make, n8n or Zapier workflow can call the Actor, flatten changes, then send its own notifications. Apify schedules can trigger repeated runs, but your external workflow must refresh baselines; a fixed scheduled input keeps comparing to the same old values.

For a data pipeline, retain URL, observedAt and currentValues as your snapshot table. Consume only hasChanges rows for your change log. Never derive a successful complete check from a failed or timed-out run.

API use

Start one run with the example JSON saved as input.json:

curl -X POST 'https://api.apify.com/v2/acts/automation-lab~selector-webpage-field-change-monitor/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' --data-binary @input.json

JavaScript with the Apify client:

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/selector-webpage-field-change-monitor').call(input);
if (run.status !== 'SUCCEEDED') throw new Error(`Incomplete run: ${run.id}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });
console.log(items);

Python:

import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/selector-webpage-field-change-monitor').call(run_input=input_data)
if run['status'] != 'SUCCEEDED':
    raise RuntimeError('Incomplete run: ' + run['id'])
print(client.dataset(run['defaultDatasetId']).list_items(limit=20).items)

MCP setup

For Claude Code:

claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/selector-webpage-field-change-monitor'

Claude Desktop, Cursor, and VS Code configuration (use each client's supported HTTP MCP setup):

{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/selector-webpage-field-change-monitor"}}}

Example prompts

• “Extract a first baseline of the title and price from this public static product page.”
• “Compare this page against my previous title and price, and return only changed fields from the observation.”

Configure authentication through your client. Discover the actual tool names and schemas with scoped tools/list. Actor selection also exposes run/storage helpers, not exactly one tool. Example authorized prompt: “Compare the heading and price on this public product page against these previous values; show changed fields only.”

Start once and retain its run and storage IDs; they are metadata, not rows. call-actor waits at most 45 seconds (default 30). If pending, use get-actor-run for the same run with 2/4/8-second backoff capped at 10 seconds and a 120-second total deadline. Set the client timeout above the server wait plus transport margin. At deadline, report pending and the run ID; do not restart to poll.

After success, use get-dataset-items with an explicit offset, limit and needed fields. Example consumer budget: pages of 20 source rows, at most 100 rows or 64 KiB of UTF-8 result content admitted to model context, whichever comes first. Enforce bytes host-side, omit/summarize oversized rows with disclosure, and report the continuation offset and partial status. If the client cannot intercept large responses, do not claim a hard byte guarantee. Keep full exports outside model context. No numeric token-savings claim is made.

Legality and responsible use

Fetch only anonymous public pages you are permitted to access. Respect terms, robots guidance, rate limits and applicable privacy law. Do not submit credentials, private intranet addresses, sensitive personal data or URLs that require an account. Only ports 80/443 are supported, and redirects/DNS destinations must remain public.

This Actor uses no AI at runtime. Apify stores your input, dataset and run logs according to your account's retention settings; delete runs/storage through Apify when no longer needed. There is no cross-run baseline cache. For help, open an issue on this Actor's Apify page.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair; secret fields and URL query strings are removed and reports are retained for 30 days. Do not put secrets into field names or baseline values.

FAQ and troubleshooting

Why did every field fail to match? Inspect raw page source. The data may be generated by JavaScript or your selectors may no longer match. This Actor does not render a browser.

Why did an unchanged field appear changed? Compare normalized strings, including case and punctuation. Prices are text; 12 and 12.00 differ.

Can it alert me or remember last time? Not automatically. Store currentValues and provide them as the next previousValues; use an integration to notify you.

Can I fetch an attribute? Set attribute, for example href, content or data-price. Raw values are normalized but URLs are not resolved.

Does an absent field indicate removal? Only when a supplied baseline differs from null. Inspect missingFields and the source before assuming a real business change.

Related workflows

This is a standalone utility: it operates on caller-supplied URLs rather than one service. Pair its JSON exports with your existing Apify dataset consumer or spreadsheet workflow. No other Actor is required, and no unrelated source support is implied.