ForHosting KIT · Web Scraping & Monitoring

Monitor a keyword

Sometimes what matters is not a price or a picture but a single word buried in a wall of text — a legal clause, an error message, a brand mention, a status label. This keyword monitoring API reads a page and tells you when a specific word or phrase shows up or drops out, without asking you to parse the whole document yourself.

● StablePer request + per check$0.002

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

Use it from WebAPIEmailApp soonTelegram soon

The single word that changes everything

A terms-of-service page that quietly adds a clause, a government notice that swaps 'pending' for 'approved', a status page that stops saying 'operational', a forum thread where your brand name finally gets mentioned — these are all cases where a single term carries the entire signal, and everything else on the page is noise. Reading the full page by hand every day to catch one word is a waste of anyone's time.

How the check reads the page

You call POST /web/monitor-keyword with a URL and the term or phrase to watch for. The task fetches the page's current text content, searches for the keyword, and records whether it is present. On each following comprobación, that presence is compared against the prior state, and you are told specifically whether the term appeared, disappeared, or stayed the same — not just that the page was checked.

A simple idea with old roots

Keyword watching predates the web itself — clipping services once paid people to scan newspapers for a client's name. The mechanics changed, the underlying need did not: someone, somewhere, needs to know the instant a specific word shows up in a specific place, whether that is a compliance term in a regulation or a competitor's name in a press release.

Made for constant, quiet vigilance

Every call is asynchronous: you get a task_id back immediately, and the actual finding arrives later through a signed webhook — the natural fit for a monitor meant to run silently in the background and only speak up when the keyword state changes — or a signed link valid for 24 hours if you prefer to pull results manually. Because each check is lightweight, it is well suited to frequent polling on a schedule you control.

Priced for exactly that kind of frequency

The cost is a flat $0.002 per request, published and simple, with no free tier and no trial period — access requires prepaid balance, keeping the service fast and abuse-free. A request that fails is retried automatically up to three times and is never charged if it does not ultimately succeed.

What you can do with it

Legal and regulatory text watch

Get notified the moment a specific clause, term, or exemption is added to or removed from a regulation or terms-of-service page.

Brand mention tracking

Watch a forum, review page, or news article for the first appearance of your company or product name.

Status page word changes

Track a status or incident page for the word 'operational' or 'outage' to know the exact moment a service state flips.

Error message detection

Monitor an internal or partner page for an error string appearing, catching a broken integration before a customer reports it.

FAQ

How do I set up keyword monitoring for a specific word?

Call POST /web/monitor-keyword with the target URL and the exact term or phrase to watch; every following comprobación reports whether that keyword's presence on the page changed.

Is keyword monitoring free to test?

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.

Can I watch for a phrase disappearing, not just appearing?

Yes, each comprobación compares the current presence of the keyword against the last recorded state, so both a term appearing and a term disappearing are detected and reported.

Does the keyword search support partial matches or just exact phrases?

The check searches for the exact term or phrase you provide within the page's text content, so specifying the precise wording you care about gives the most reliable result.

How often can I run this keyword check?

As often as your schedule calls the endpoint; there is no artificial limit, and because each request is billed individually at $0.002, frequent checks stay predictable and affordable.

How do I get alerted when the keyword changes?

Configure a signed webhook to receive the result the instant a change is detected, or use a signed link valid for 24 hours if you prefer to check results manually.

Can I monitor multiple keywords across many pages?

Yes, each URL-and-keyword pair is its own asynchronous request, so bulk monitoring across many pages and terms is a matter of triggering monitor-keyword for each combination.

What happens if the page fails to load during a check?

The task retries automatically up to three times; if it still fails, you receive a clear error instead of a false negative, and the failed attempt is not charged.

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

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-keyword \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"input":"…"}'

const res = await fetch("https://api.kit.forhosting.com/web/monitor-keyword", {
  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-keyword",
    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-keyword", 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-keyword", 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_keyword",
  "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 →