Test
10,000 pages
$3.75
$0.38/1K pages
- Try it on your real URLs
- Same API as the biggest pack
- Credits never expire
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
| 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.
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.
Starter
50,000 pages
$14.25
$0.28/1K pages
- An AI agent or a RAG prototype
- Crawl a documentation site
- Credits never expire
Build
100,000 pages
$21.75
$0.22/1K pages
- Production agents and RAG pipelines
- Batch and crawl jobs
- Credits never expire
In every plan: Main-content extraction · JavaScript rendering when needed · Failed and refused pages not charged · Credits never expire
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.