Detect changes on any page and get alerted

Watch a page for changes: a price, a stock status, a policy page, a competitor’s pricing table, a job board. Each check fetches the page, compares it with the last snapshot, and sends you a diff when it differs. Uses: Fetch with response_type=markdown or css_extractor, Batch scheduled jobs

How it works

Fetch reads the page. Fetch with mode=auto returns either the whole page as markdown, or only the fields you name in a css_extractor. Watching fields ignores changes elsewhere on the page, such as ads or timestamps.
Your code hashes and diffs. The script hashes the content and compares it with the hash stored in snapshots.json. When they differ, it builds a line-by-line diff.
The alert goes out. The diff goes to a Slack incoming webhook when SLACK_WEBHOOK_URL is set, and to the console otherwise.
A schedule repeats it. Run the script from cron, or let a scheduled Batch job fetch the pages and run the same diff on its results.

Ask your AI agent

With the Zenrows MCP server connected to Claude, Cursor or any MCP client, paste this prompt. Your agent picks the right Zenrows tools and settings on its own.

Use Zenrows to read https://www.scrapingcourse.com/ecommerce/product/adrienne-trek-jacket/
and save the product name, price and description. Then read it again and
tell me exactly what changed between the two versions, or confirm that nothing did.

Watch pages for changes

List what to watch in WATCHES. An entry with a css_extractor watches those fields. An entry without one watches the whole page as markdown. Save this as watch.py and run python watch.py: the first run saves a baseline, every later run compares against it.

Python (Requests)

import difflib
import hashlib
import json
import os
from pathlib import Path

import requests

ZENROWS_API_KEY = "YOUR_ZENROWS_API_KEY"
SLACK_WEBHOOK_URL = os.environ.get("SLACK_WEBHOOK_URL")  # optional
SNAPSHOTS = Path("snapshots.json")

# What to watch: a css_extractor watches fields, no css_extractor watches the whole page as markdown
WATCHES = [
    {
        "url": "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/",
        "css_extractor": {"name": "h1.product_title", "price": "p.price"},
    },
    {"url": "https://www.scrapingcourse.com/ecommerce/product/adrienne-trek-jacket/"},
]

def fetch_content(watch: dict) -> str:
    params = {"apikey": ZENROWS_API_KEY, "url": watch["url"], "mode": "auto"}
    if "css_extractor" in watch:
        params["css_extractor"] = json.dumps(watch["css_extractor"])
    else:
        params["response_type"] = "markdown"
    response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
    response.raise_for_status()
    if "css_extractor" in watch:
        return json.dumps(response.json(), indent=2, sort_keys=True)
    return response.text

def alert(message: str) -> None:
    if SLACK_WEBHOOK_URL:
        requests.post(SLACK_WEBHOOK_URL, json={"text": message}, timeout=30)
    else:
        print(message)

def main() -> None:
    snapshots = json.loads(SNAPSHOTS.read_text()) if SNAPSHOTS.exists() else {}

    for watch in WATCHES:
        url = watch["url"]
        content = fetch_content(watch)
        digest = hashlib.sha256(content.encode()).hexdigest()
        previous = snapshots.get(url)

        if previous is None:
            print(f"Baseline saved: {url}")
        elif previous["hash"] == digest:
            print(f"No change: {url}")
        else:
            diff = difflib.unified_diff(
                previous["content"].splitlines(), content.splitlines(),
                "before", "after", lineterm="", n=0,
            )
            alert(f"Change detected on {url}\n" + "\n".join(list(diff)[:40]))

        snapshots[url] = {"hash": digest, "content": content}

    SNAPSHOTS.write_text(json.dumps(snapshots, indent=2))

if __name__ == "__main__":
    main()

To send alerts to Slack, create an incoming webhook and export its URL as SLACK_WEBHOOK_URL. The same {"text": ...} payload works with Microsoft Teams workflows, Discord (as content) and most chat tools.

Run it on a schedule

With cron. Check every hour from your own server:

0 * * * * cd /path/to/watch && /usr/bin/python3 watch.py >> watch.log 2>&1

With a scheduled Batch job. Zenrows fetches the pages on its schedule, and your code only diffs the results. Each task carries its own zenrows_params, so one job mixes field watches and full-page watches. Run this once to create the job (pip install zenrows):

Python (SDK)

import json

from zenrows import ZenRowsBatchClient
from zenrows.batch import Calendar, Daily

client = ZenRowsBatchClient(api_key="YOUR_ZENROWS_API_KEY")

job = client.submit_scheduled(
    Calendar(times_of_day=["09:00"], cadence=Daily(), timezone="Europe/Madrid"),
    [
        {
            "url": "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/",
            "zenrows_params": {"css_extractor": json.dumps({"name": "h1.product_title", "price": "p.price"})},
        },
        {
            "url": "https://www.scrapingcourse.com/ecommerce/product/adrienne-trek-jacket/",
            "zenrows_params": {"response_type": "markdown"},
        },
    ],
    zenrows_params={"mode": "auto"},
    webhook={"url": "https://your-app.com/webhooks/zenrows"},
)
print("Scheduled job:", job.job_id)

Zenrows posts a run.completed event to the webhook after each run. Call this function from your webhook handler (or from cron, after the scheduled time) to diff the run’s results against your snapshots:

Python (SDK)

import difflib
import hashlib
import json
from pathlib import Path

from zenrows import ZenRowsBatchClient

SNAPSHOTS = Path("batch-snapshots.json")  # its own file: Batch results are stored as returned
client = ZenRowsBatchClient(api_key="YOUR_ZENROWS_API_KEY")

def check_latest_run(job_id: str) -> None:
    snapshots = json.loads(SNAPSHOTS.read_text()) if SNAPSHOTS.exists() else {}
    run = client.job(job_id).run

    for task in run.results(status="successful"):
        url = str(task.url)
        content = run.download_task_to_memory(task).decode()
        digest = hashlib.sha256(content.encode()).hexdigest()
        previous = snapshots.get(url)

        if previous and previous["hash"] != digest:
            diff = difflib.unified_diff(
                previous["content"].splitlines(), content.splitlines(),
                "before", "after", lineterm="", n=0,
            )
            print(f"Change detected on {url}\n" + "\n".join(list(diff)[:40]))
        else:
            print(f"{'No change' if previous else 'Baseline saved'}: {url}")

        snapshots[url] = {"hash": digest, "content": content}

    SNAPSHOTS.write_text(json.dumps(snapshots, indent=2))

Zenrows delivers each webhook event at least once, so deduplicate on the X-ZenRows-Event-Id header. To verify that deliveries come from Zenrows, enable signed webhooks, see Verify signed webhooks.

Example output

Output of watch.py: the first run, then a second run with no changes:

Baseline saved: https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/
Baseline saved: https://www.scrapingcourse.com/ecommerce/product/adrienne-trek-jacket/
No change: https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/
No change: https://www.scrapingcourse.com/ecommerce/product/adrienne-trek-jacket/

A later run, after setting the stored prices to

79.00 and

62.00 in snapshots.json to simulate a change. The field watch shows the changed field, the markdown watch shows the changed line:

Change detected on https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/
--- before
+++ after
@@ -3 +3 @@
-  "price": "$79.00"
+  "price": "$69.00"
Change detected on https://www.scrapingcourse.com/ecommerce/product/adrienne-trek-jacket/
--- before
+++ after
@@ -36 +36 @@
-$62.00
+$57.00

Customize it

Change	How
Watch a table or a list	Use `outputs=tables` or a `css_extractor` with a list selector, see Output filters
Ignore noise on the page	Watch only the fields that matter with a `css_extractor`, instead of the whole markdown
Watch plain text	Set `response_type=plaintext`, see Plain text
Watch content from one country	Add `proxy_country=us` (any ISO code), see Proxy country
Check every few hours	Replace `Calendar` with `Rate(every=6, unit="hour")`, see Scheduled jobs
Send email instead of Slack	Replace the body of `alert()` with your email provider’s API call

Troubleshooting

Every run reports a change: the page includes content that changes on each load, such as a timestamp, a session token or rotating ads. Switch that watch to a css_extractor with only the fields you care about.
The diff is empty but a change was reported: the content changed only in whitespace or line order. Normalize the content before hashing, for example " ".join(content.split()).
A field comes back empty: the selector no longer matches. Inspect the element in your browser and update the css_extractor.
Webhook events arrive twice: deliveries are at least once. Store each X-ZenRows-Event-Id you process and skip repeats.

Build a price monitor

Store price history and alert on drops.

Run a Batch job on a schedule

Every schedule option for Batch jobs.

Get notified when a Batch job finishes

Receive and verify Batch webhooks.

Start Here

Foundations Course

Fetch Recipes

Extract Recipes

Crawl Recipes

Batch Recipes

Browser Recipes

Pipelines

Use Cases

By Surface

Production

Detect changes on any page and get alerted

How it works

Ask your AI agent

Watch pages for changes

Run it on a schedule

Example output

Customize it

Troubleshooting

Build a price monitor

Run a Batch job on a schedule

Get notified when a Batch job finishes

Turn any web page into LLM-ready markdown

​How it works

​Ask your AI agent

​Watch pages for changes

​Run it on a schedule

​Example output

​Customize it

​Troubleshooting

​Related recipes

Build a price monitor

Run a Batch job on a schedule

Get notified when a Batch job finishes

Turn any web page into LLM-ready markdown

How it works

Ask your AI agent

Watch pages for changes

Run it on a schedule

Example output

Customize it

Troubleshooting

Related recipes