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 only when the content meaningfully changes, so nobody has to babysit a tab.

● StablePer request + per check$0.002

How it works & API — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram 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 content, not just a timestamp.

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 content against the last known version; when a meaningful difference is detected, a signed webhook fires with the change details, 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 meaningful change

Pages redraw constantly for reasons that have nothing to do with their substance — a rotating banner ad, a session token embedded in a script tag, a timestamp in a footer. Flagging every one of those as a 'change' would make the whole feature useless through alert fatigue. This endpoint focuses on the content that matters, so a small headline update or a new clause in a policy surfaces clearly instead of getting buried under noise from a page that redraws itself every few seconds.

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 actually changed?

It compares the page's meaningful content against the previously recorded version and only triggers on differences that matter, filtering out noise like rotating ads or session tokens.

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 cosmetic changes like a rotating banner?

No, the endpoint is built to surface meaningful content changes rather than every visual redraw of the page.

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

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

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 &#39;{"input":"…"}'

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({
    "input": "…"
  })
});
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[&#39;KIT_KEY']}"},
    json={
    "input": "…"
},
)
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" => &#39;{"input":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"input":"…"}`)
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

{
  "input": "…"
}

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 →