# Website change monitoring: diff public pages as clean Markdown

> Monitor public web pages for changes: read pricing pages, policies and changelogs as Markdown on a schedule, diff the text and alert. From $0.07/1K pages.

- URL: https://webreaderapi.com/use-cases/monitoring/
- Last updated: 2026-10-22
- Publisher: WebReaderAPI (https://webreaderapi.com)

Comparing raw HTML raises an alert every time an ad or a token changes. Comparing the main content as Markdown only flags what a reader would notice: a new price, a reworded clause, a fresh changelog entry.

**Quick answer — How can I monitor web pages for content changes?**

Read each page on a schedule as Markdown of its main content, store the text, and compare it with the previous version; alert only when the text changes. **WebReaderAPI** reads up to 100 URLs per batch job, removes ads and menus so they cannot trigger false alarms, and charges one credit per page from $0.07/1K pages as of October 2026. No KYC; pay in crypto.

## Monitoring with WebReaderAPI

| Attribute | Value |
| --- | --- |
| Endpoint | `POST https://webreaderapi.com/api/v1/batch`, then `GET https://webreaderapi.com/api/v1/jobs/{job_id}` |
| Batch size | Up to 100 URLs per batch job |
| What is compared | Markdown of the main content, without ads, menus or banners |
| Billing | 1 credit = 1 page read without a browser; 2 credits when the page needs a browser to render JavaScript. A request that fails, or that a site's robots.txt refuses, is not charged |
| Example volume | 200 pages checked daily = about 6,000 pages a month |
| Price | $3.75 for 10,000 pages; credits never expire |

## What is worth monitoring?

Pages whose wording matters to your business and that change without notice:

- **Pricing pages** of suppliers and competitors, to see new plans and price moves.
- **Terms, privacy and refund policies** you depend on, to catch clauses that change.
- **Changelogs and release notes** of tools you build on, to react to breaking changes.
- **Documentation pages** your product links to, to fix broken guidance quickly.
- **Public notices** from regulators or standards bodies in your field.

Keep the list to public pages. Personal profiles and pages behind a login are out of scope.

## Why diff Markdown instead of HTML?

Because HTML changes all the time without the content changing. Rotating ads, session tokens, timestamps in footers and A/B test markup make two loads of the same page differ. A diff on HTML turns that noise into alerts, and people stop reading them.

Main-content Markdown removes most of the noise before you compare. What is left is the text a person reads: headings, paragraphs, lists and tables. A diff on that text is short, readable and worth an alert.

*Python: check a list of pages and print what changed*

```python
import difflib
import json
import os
import pathlib
import time

import requests

API = "https://webreaderapi.com/api/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}
STORE = pathlib.Path("snapshots.json")
URLS = [
    "https://example.com/pricing",
    "https://example.com/legal/terms",
    "https://example.com/changelog",
]

old = json.loads(STORE.read_text(encoding="utf-8")) if STORE.exists() else {}
job = requests.post(API + "/batch", headers=HEADERS, json={"urls": URLS}, timeout=60).json()
results, cursor, delay = [], None, 5
while True:
    params = {"cursor": cursor} if cursor else {}
    page = requests.get(API + "/jobs/" + job["job_id"], headers=HEADERS, params=params, timeout=60).json()
    results += page.get("results", [])
    cursor = page.get("next_cursor")
    if page["status"] == "done" and not cursor:
        break
    if not cursor:
        time.sleep(delay)
        delay = min(delay * 2, 60)

new = dict(old)
for item in results:
    if "markdown" not in item:
        print("not read:", item["url"], item.get("error", {}).get("code"))
        continue
    before = old.get(item["url"], "")
    if before and before != item["markdown"]:
        diff = difflib.unified_diff(before.splitlines(), item["markdown"].splitlines(), lineterm="", n=0)
        print("CHANGED:", item["url"])
        print("\n".join(list(diff)[:40]))
    new[item["url"]] = item["markdown"]
STORE.write_text(json.dumps(new, ensure_ascii=False), encoding="utf-8")

```

## How often should I check, and how politely?

Check as often as the page realistically changes, and no more. Daily suits pricing pages and changelogs; weekly suits policies and documentation. A page read every hour rarely tells you more than one read every day, and it costs 24 times as much.

WebReaderAPI follows robots.txt for every page and honours a site's `Crawl-delay` in crawl jobs. Pages the site disallows are skipped and not charged, so a strict site simply drops out of your report. Ask the owner if you need access to a page that refuses robots.

## What does monitoring cost?

One credit per page per check. Some examples at the prices of October 2026:

- **50 pages, daily:** about 1,500 pages a month. 10,000 pages ($3.75) last more than six months.
- **200 pages, daily:** about 6,000 pages a month. 50,000 pages ($14.25) last about eight months.
- **1,000 pages, weekly:** about 4,300 pages a month, close to the previous case.

Pages that need a browser use two credits; set `render=false` for pages you know are plain HTML to keep the count at one.

## Which pack suits monitoring?

Multiply pages by checks per month, then pick a pack that lasts a few months. Credits never expire.

| Plan | Quantity | Price | Price per unit |
| --- | --- | --- | --- |
| Test | 10,000 pages | $3.75 | $0.38/1K pages |
| Starter | 50,000 pages | $14.25 | $0.28/1K pages |
| Build | 100,000 pages | $21.75 | $0.22/1K pages |

In every plan: Main-content extraction · JavaScript rendering when needed · Failed and refused pages not charged · Credits never expire

**Before you pay**

- Minimum top-up $25. Top up once in crypto, then buy any plan from your balance.
- Your balance has no end date and can buy page credits at any time. If a pack costs less than the minimum top-up, the amount you added only to reach that minimum can be sent back on request within 30 days of the payment, in USDT or USDC, as long as you have not spent it. Any other balance is not refunded unless the law says otherwise.
- Credited once your payment is checked on the blockchain. Typical network confirmation time: BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Change monitoring: common questions

### Does WebReaderAPI send alerts?

No. It reads pages and returns Markdown; your script compares versions and sends the alert by email, chat or ticket. The code above prints the changed lines as a starting point.

### How do I avoid false alarms from dates and counters?

Compare main-content Markdown, not HTML, and strip lines you know change on every load, such as "updated 5 minutes ago", before diffing. Most rotating elements are already removed by main-content extraction.

### Can I monitor pages that need JavaScript?

Yes. With `render=auto`, pages that are empty without JavaScript are rendered in a browser for two credits. Pages that work without it stay at one.

### Can I monitor a whole site rather than a list of pages?

Yes: run a crawl job instead of a batch, then compare page by page. For large sites, compare the sitemap's `lastmod` dates first and re-read only the pages that moved.

---

WebReaderAPI: WebReaderAPI is a web reader API for AI agents that turns any public web page into clean Markdown, paid in crypto with no ID upload. Prepaid credits from $0.07/1K pages never expire, and robots.txt is respected. No KYC — no ID, no selfie, no documents. Pay in crypto.