ForHosting KIT · Web Scraping & Monitoring

Monitor a page for changes

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. 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.

● StablePer request + per check$0.002

How it works & API — $0.002 Examples and details

Use it from Web API onlyAPIEmailTelegramApp soon

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. 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

The check compares the page's extracted text, not the raw HTML — so scripts and markup noise are stripped out before the comparison. 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. 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.

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.

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.

Documentation and changelog alerts

An engineering team tracks a third-party API's changelog page so breaking changes don't arrive as a surprise.

FAQ

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.

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.

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

POSThttps://api.kit.forhosting.com/web/monitor-changes

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

Per request$0.002

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.

Read the full KIT documentation →