Guide
How to turn any website into a change API
Most of the pages you care about will never ship an API. Competitor pricing, vendor ToS PDFs, regulator indexes, partner changelogs: the data is right there in the HTML, and there is no endpoint to call. You have three realistic options. Build a scraper and own the breakage. Pay a scraping API to extract the whole page on demand. Or turn the page into a change feed: a monitor that watches it for you and pushes JSON only when something that matters actually changed. This post is that third path, end to end, with Page Deltas.
Free plan · 10 monitored URLs or sitemaps · unlimited checks (best-effort) · AI filtering and summaries · REST API, MCP, and signed webhooks on every plan · no credit card
{
"event": "sitemap.new_urls",
"monitor": "https://www.hubspot.com/sitemap.xml",
"detected_at": "2026-06-15T19:30:00Z",
"new_urls": [
"https://www.hubspot.com/case-studies/workleap",
"https://www.hubspot.com/products/artificial-intelligence/use-cases/sales-meeting-prep-and-follow-up",
"https://www.hubspot.com/email-signature-generator/create-rules-gmail"
]
}Scraper vs scraping API vs change feed
Honest rule of thumb: if you need thousands of pages as a dataset, use a scraping API. If you need to know when one public page moved in a way that matches a brief, a change feed is less code and less babysitting.
DIY scraper
What you get: raw HTML you parse yourself. Best for full control on weird sites. Effort is high (selectors, proxies, rendering, retries). When the site redesigns, your parser breaks silently. Freshness is whenever your cron runs. Typical cost: infra plus your time.
Scraping API
What you get: structured extraction per request. Best for bulk extraction of many pages. Effort is low to medium. The vendor absorbs most breakage. Freshness is whenever you call it. Typical cost: per-request credits.
Change feed (this guide)
What you get: a JSON event when something meaningful changed, with an AI summary. Best for "tell my system when this page changes." Effort is low: one monitor create, then webhook or poll. Content extract plus LLM brief still decide what matters. Adaptive checks; push to your endpoint on match. Per monitored URL on your plan (checks are not metered on Page Deltas).
What you will build
Base URL: https://api.pagedeltas.com. All endpoints are under /api. Successful responses are JSON.
Account and API key
Create a free Page Deltas org and an API key.
Monitor with a brief
Create a monitor on a public URL with a natural-language brief (the filter).
Poll or webhook
Either poll GET /api/monitors/{id}/changes, or attach a generic webhook channel so each match POSTs signed JSON to your app.
Optional MCP
Connect the same key to Claude, Cursor, or VS Code over MCP.
Setup: turn a page into a change feed
Five steps from API key to signed webhook. Prefer a webhook when you want push instead of pull.
Create an account and an API key
Sign up at pagedeltas.com/register. No credit card. Free plan: 10 monitored URLs or sitemaps, unlimited checks (best-effort frequency), AI filtering and summaries, unlimited teammates, Slack / Discord / Teams / email / signed webhooks, 14-day history, REST API and MCP. In the app: Settings → API keys (editor or admin). Create a key and copy it immediately; it is shown once. export PAGEDELTAS_TOKEN="pdt_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx". Keys are org-scoped and act with admin-level access inside that org. They are not tied to a member, so removing a teammate does not revoke the key. Delete the key to cut access. Treat it like a password: env var or secret store, never a committed config file.
Create a monitor (cURL)
POST https://api.pagedeltas.com/api/monitors with Authorization: Bearer $PAGEDELTAS_TOKEN and JSON body: url, nl_description (the brief), optional filter_prompt, and channel_ids: []. Example brief: "Competitor pricing page. Alert when any plan price changes, a plan is added or removed, or quotas and limits change. Ignore cookie banners, A/B layouts, and rotating testimonials." There is no frequency field. Cadence is adaptive (active pages more often, quiet ones less; paid plans get priority checking). Use POST /api/monitors/{id}/check-now for an on-demand run (rate limited to 1/minute/monitor). nl_description is the brief the LLM uses to decide whether a change matters. Vague briefs recreate a visual-diff firehose inside your webhook. Optional: filter_prompt, css_selector, xpath_selector, is_pdf, and channel_ids (per-monitor channel overrides; omit to use org defaults). Public web only. Pages behind a login are not supported yet. Sitemap monitors are a separate resource (/api/sitemap-monitors) when the job is "did a brand-new URL appear?" rather than "did this page get rewritten?"
Poll the change feed
GET https://api.pagedeltas.com/api/monitors/{id}/changes?limit=50 with the Bearer token. Most recent changes first (default 50, max 100). There is no cursor. Track the latest detected_at you have already seen. Each change includes id, detected_at, and summary: a plain-language AI description of what matched the brief, not a raw HTML diff. Pipe summary into Slack, a ticket, or another agent.
Same create + poll in Python
Use requests with Authorization Bearer and Content-Type application/json. POST /api/monitors with url, nl_description, and channel_ids: []. Read monitor["id"] from the response. Then GET /api/monitors/{monitor_id}/changes with limit=50 and print each change's detected_at and summary. Run that on a schedule if you must poll. Prefer a webhook when you want push instead of pull.
Skip polling, get pushed JSON (HMAC-signed webhooks)
In the app: Channels → Add a channel → Generic webhook. Paste your HTTPS receiver URL. Copy the channel secret when it is shown (once). Click Send test. Or create the channel via API (POST /api/alert-channels), then attach it with PUT /api/monitors/{id}/alert-channels, or leave channel_ids empty so the monitor uses org defaults. Each matching change POSTs flat JSON to your URL with Content-Type application/json and X-Signature: sha256=<hex>. Fields include event (change.detected), monitor_id, monitor_url, monitor_name, change_id, detected_at, summary, before_screenshot_url, after_screenshot_url, and dashboard_url. Verify X-Signature as HMAC-SHA256 of the raw request body with your channel secret (header form sha256=<hex>). Hash the exact bytes before JSON parsing, or verification fails. New fields may be added over time: ignore unknown keys. Delivery notes: one attempt per channel per alert today (no automatic retries), so respond quickly and accept duplicates defensively. Non-2xx or network errors mark that delivery failed; the monitor itself is not paused for delivery failures. Every attempt is audited server-side. For humans instead of code, use Slack, Discord, Teams, or email channels the same way. The Slack wiring walkthrough is How to get website change alerts in Slack.
Optional: drive monitors from Claude, Cursor, or VS Code (MCP)
Same API key. Streamable HTTP MCP endpoint: https://api.pagedeltas.com/mcp. Agents get tools such as create_monitor, list_monitor_changes, create_alert_channel, and sitemap helpers. Cookie sessions are not accepted on MCP. Prefer a webhook channel for event-driven systems that should not poll.
Cursor mcp.json
In ~/.cursor/mcp.json set mcpServers.pagedeltas.url to https://api.pagedeltas.com/mcp and headers.Authorization to Bearer pdt_xxxxxxxx. Restart Cursor so the tools appear.
Full client snippets
Claude Code, VS Code, and Claude Desktop via mcp-remote live in the MCP docs.
MCP docs →Your brief is the query language
With a REST API you filter with query params. With a change feed, the filter is the natural-language brief on the monitor. Page Deltas extracts the page, compares to the last check, and asks an LLM whether the delta matches your brief. Matched alerts arrive with a written summary and before/after screenshots. Write the brief like you would brief a teammate.
Pricing
A plan price changes or a new plan tier appears.
Tenders / RFPs
A new RFP is posted in our NAICS scope.
API docs
The API docs add, remove, or deprecate an endpoint.
Hiring
A senior engineering role is posted; ignore non-engineering roles.
General monitoring how-to
Same philosophy as our general monitoring how-to and the filters and descriptions guide.
How to monitor website changes →Filters guide
Examples that work and ones that do not when writing the brief.
Filters and descriptions →Quotas that actually matter (and ones that do not)
On Page Deltas, the limit you plan around is how many URLs (or sitemaps) you watch, not a monthly check quota. API read/write endpoints currently have no per-key rate card beyond sensible use. The exception is check-now: 1 request / minute / monitor (429 + Retry-After when you hit it). Hitting your plan's URL limit returns 422 with current and limit. Classic check-metered tools force you to do the math ("hourly on one page ≈ 720 checks/month"). Here you pick the pages and write the brief. Cadence adapts.
Free
10 monitored URLs · 14-day history · unlimited checks (best-effort), AI, API, MCP, all five alert channels · $0
Starter
150 monitored URLs · 30-day history · $29/mo · priority checking
Pro
1,000 monitored URLs · 90-day history · $79/mo
Business
5,000 monitored URLs · 365-day history · $199/mo
Scale
20,000 monitored URLs · 730-day history · $499/mo
Enterprise
Custom URLs and history · SSO / SCIM
How this differs from a Visualping-style change API
Visualping's developer posts lean on fixed intervals, optional CSS/XPath scoping, a monthly check quota, and a large webhook field set around diffs and importance flags. That works when the job is "fire when the pixels moved, then let my code decide." Page Deltas is built for "only wake my system when the change matches this brief." This post is the wiring guide; the full plan-for-plan product comparison lives on Page Deltas vs Visualping.
Natural-language brief first
The primary filter is the brief. Selectors are optional, not required.
Adaptive cadence
No typing an interval string. Active pages are checked more often; quiet ones less.
Flat webhook payload
Centered on summary plus screenshot URLs plus HMAC X-Signature.
Unlimited checks; pay for URL count
Every plan includes unlimited checks. You pay for how many URLs you watch.
MCP on the same keys
MCP uses the same API keys as the REST surface.
Full product comparison
Plan-for-plan comparison of Page Deltas vs Visualping.
Page Deltas vs Visualping →Honest limits
Know what this change feed is and is not before you wire production clients.
Public pages only
Marketing sites, public PDFs, public careers boards, public sitemaps. Login-walled portals are on the roadmap, not available today.
Not a visual-regression / defacement tool
If the job is "did this pixel move 20px," a visual-diff product still wins.
Not LinkedIn or X activity
Page Deltas watches the open web. Person-level LinkedIn/X activity belongs on MultiFollow. Keyword mentions across LinkedIn, X, Reddit, and more belong on KWatch.
Webhook delivery is single-attempt today
Build idempotent receivers.
Do not invent response field names
Copy shapes from the live API reference and ignore unknown JSON fields.
API reference →Related guides and docs
Deeper wiring for humans in Slack, the no-code quickstart, and the live API shapes.
Slack change alerts
Wire the same monitor to a Slack incoming webhook for humans instead of code.
How to get website change alerts in Slack →API reference
Live request and response shapes. Copy fields from here; ignore unknown JSON keys.
API reference →Frequently asked questions
- How do I get data from a website that has no API?
- Three options: build a scraper, use a scraping API for bulk extraction, or point a change-monitoring API at the page and consume the JSON change feed. For "notify my system when this page changes," the change feed is usually the least code: create a monitor, then webhook or poll.
- Can I do this without writing code?
- Yes. Create the monitor in the dashboard, add a generic webhook (or Slack / Teams / Discord / email) under Channels, write the brief, and click Send test. The quickstart is the no-code path.
- What's the difference between a scraping API and a change-monitoring API?
- A scraping API extracts page content each time you call it. A change-monitoring API watches the page and emits only the changes, with the AI summary already computed. Extraction problems want scrapers. "Did anything that matches my brief change?" wants a change feed.
- Does API or webhook access cost extra?
- No. REST API, MCP, and signed webhooks are on every plan, including Free. Usage is gated by your monitored-URL limit, not a separate API credit meter.
- Can AI agents create monitors for me?
- Yes. Point an MCP client at https://api.pagedeltas.com/mcp with a Bearer API key. See the MCP docs.
Author
Julien, Product Manager at Page Deltas. Pick one public URL you already refresh by hand. Create a free account, mint an API key, create the monitor with a one-sentence brief, attach a generic webhook, verify the HMAC signature once, and wait for the first real match. Tighten the ignore list after the first noisy alert. That is usually the whole change-API setup.
Start with one page as a change feed
Free plan, no card. Create an account, generate an API key, paste the URL you already babysit, drop in a brief from the filters guide, and either poll /changes or POST signed JSON to your own endpoint.