Monitor a page for changes
Point it at a vendor's terms of service or a regulator's notices page, choose how often to check, and get notified only when the visible text actually differs from the last version. No more reloading tabs to spot a removed clause. You pay per use, with no subscription.
Most pages worth watching don't announce when they change — a terms-of-service update, a removed clause, a new line in a changelog, all slip by silently unless someone happens to reload at the right moment.
The changes nobody announces
Most pages worth watching never tell you when they change. A vendor quietly updates its terms of service, a clause disappears, a new line appears in a changelog or a regulator posts a notice, and it all slips by unless someone reloads at the right moment. Revisiting pages by hand does not scale past a handful of addresses and is easy to forget for weeks, until the change already mattered. Legal teams tracking vendor terms, compliance teams watching a regulator's notices, security researchers following a disclosure page and journalists monitoring government announcements all face the same quiet risk.
How the comparison works and how to keep alerts clean
Each check compares the page's visible text with the last version seen, after scripts and markup are stripped away, and you are notified only when that text is different, not after every check. The monitor does not judge which text matters: a rotating headline, a date in the footer or a visitor counter shown as text also counts as a change. So choose pages whose core text is stable and point at the most specific address, such as the policy page itself instead of a busy homepage. Product teams use the same approach to catch an update to a competitor's pricing or feature page the day it goes live.
The problem with 'just check it sometimes'
Manually revisiting a page to see if it changed doesn't scale past a handful of URLs, and it's exactly the kind of task that's easy to forget for weeks until the change already mattered. Legal teams tracking a vendor's terms, security researchers watching a disclosure page, and journalists monitoring a government notice all face the same quiet risk: the page changed, and nobody was looking.
What counts as a change
The check compares the page's extracted text, not the raw HTML — so scripts and markup noise are stripped out before the comparison. The practical fix is to watch pages whose core text is stable, and to point at the most specific URL — the policy page itself, not a busy homepage — so the signal stays clean.
What you can do with it
Terms of service and policy tracking
A legal team gets notified the moment a vendor updates its terms of service instead of discovering the change months later.
Government and regulatory notices
A compliance team watches a regulator's public notice page for updates that affect how the business operates.
Competitor page watching
A product team monitors a competitor's pricing or feature page to catch updates the same day they go live.
FAQ
Can I monitor many pages at once?
Yes, submit a separate task per URL and each is priced independently at the flat per-request rate.
What happens if a check fails because the page is temporarily down?
The task retries automatically up to three times; if it still fails you get a clear error and aren't charged.
Will I get alerted for minor changes like a rotating banner?
It ignores purely visual redraws that don't change the text, and it strips scripts and markup — but if a banner's text or a footer date changes in the page's visible text, that does count as a change. Watch a stable page or the most specific URL to keep the noise down.
Is the monitored page content stored long-term or used for training?
No, content is retained only as needed to detect changes and is deleted after the retention period, never used for training.
Which page should I point the monitor at?
The most specific address with stable core text, such as the policy page itself rather than a busy homepage. That keeps alerts meaningful, because any change in the visible text counts as a change.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
One authenticated POST creates the task; the result comes back by webhook or a signed link. This capability is currently available through the API, not as an interactive Web tool.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/monitor-changes \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://example.com"}'const res = await fetch("https://api.kit.forhosting.com/web/monitor-changes", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://example.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/monitor-changes",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://example.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/monitor-changes", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://example.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://example.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/monitor-changes", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"url": "https://example.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.monitor_changes",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
timeout_sec | 30 |
max_crawl_pages | 25 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
This website change monitor API checks a page on your schedule and sends a webhook when the page's text content changes, so nobody has to babysit a tab.
The problem with 'just check it sometimes'
The monitor-changes endpoint removes the guesswork by checking on a defined interval and comparing the page's text, not just a timestamp header.
How monitoring actually runs
You submit a URL to POST /web/monitor-changes, get a task_id back, and the task is tracked going forward. Each check compares the current text against the last known version; when the text differs, a signed webhook fires with the change, or the result is made available through a signed link valid for 24 hours if you'd rather poll than receive a push.
What counts as a change
But it does not try to judge which text 'matters': any change in the visible text counts, including a rotating headline, a date in the footer, or a visitor counter rendered as text.
A quiet piece of the open web's history
Watching pages for changes predates modern APIs by decades — early web users relied on browser extensions and desktop tools that polled pages and emailed a diff, long before webhooks existed as a delivery mechanism. The underlying need never went away; what changed is that a webhook now lets a detected update trigger an automated workflow directly, instead of a human reading an email and deciding what to do next.
Building it into an automated watch
Because this task is priced simply at $0.002 per request with no per-URL surcharge, it's built for running continuously across a watchlist rather than as an occasional spot check. Point the webhook at a workflow that opens a ticket, posts to a team channel, or archives a snapshot, and the monitoring runs unattended for as long as the watch stays active.
Integration use cases
Documentation and changelog alerts
An engineering team tracks a third-party API's changelog page so breaking changes don't arrive as a surprise.
Technical questions
How does the website change monitoring API decide something changed?
It extracts the page's text (dropping scripts and markup) and compares it against the previously recorded text; any difference in that text triggers a notification. It does not judge which changes 'matter', so a date or counter rendered in the text can also trigger it.
Is there a free tier for the website change monitor API?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
How much does the change monitoring API cost?
It's $0.002 per request, a flat rate with no additional per-URL charge.
How do I get notified when a page changes?
Through a signed webhook, which we recommend for automated alerts, or a signed link valid for 24 hours if you'd rather check manually.