ForHosting KIT · Web Scraping & Monitoring

Track a price

Prices move faster than any human can watch a page, especially when a competitor runs flash discounts or a supplier adjusts costs overnight. This price monitoring API reads the price on a given page at the interval you choose and reports the moment it changes, so pricing decisions run on current data instead of yesterday's screenshot.

● StablePer request + per check$0.040

How it works & API — $0.040 + $0.001/check How it works & API

Use it from WebAPIEmailApp soonTelegram soon

The problem behind the price tag

Retailers repricing against competitors, marketplace sellers tracking a supplier's cost, and procurement teams watching a vendor's list price all share the same headache: the number they need lives on a page nobody has time to check by hand, several times a day, across dozens or hundreds of products. Manual checking does not scale, and a stale price feeding into a repricing rule can quietly cost margin.

How the extraction works

A call to POST /web/monitor-price takes a URL and, when needed, a selector or hint for where the price lives on the page — useful for sites that show multiple prices, like a strikethrough original next to a sale figure. The task fetches the page, extracts the current price and currency, and compares it against the last recorded value for that URL, flagging a change only when the number actually moved.

From shelf-tag wars to algorithmic repricing

Price watching is as old as retail itself — sending someone to walk a competitor's aisle with a notepad and jot down what was on the shelf tag that morning. E-commerce turned that slow, manual ritual into a technical problem: prices now change by algorithm, sometimes within minutes and often outside business hours, and the only realistic way to keep up is to watch programmatically at the same speed the market moves, rather than checking once a day and hoping nothing important happened in between.

Fitting into a pricing pipeline

Every request is asynchronous. You get a task_id right away, and the extracted price arrives later through a signed webhook — the natural choice if you feed a repricing engine or a spreadsheet automatically — or a signed link valid for 24 hours for manual review. Scheduling the checks themselves is yours to control, whether that means hourly for volatile categories or daily for stable ones.

What it costs and what it does not

The base cost is $0.040 per request plus $0.001 per comprobación, published with no hidden units. There is no free tier and no trial: access needs prepaid balance, which keeps the service fast and abuse-free. Failed extractions retry automatically up to three times and are never billed if the task ultimately fails.

What you can do with it

Competitor repricing feed

Pull a rival's price for a matching SKU every few hours and feed it straight into your own repricing rules.

Supplier cost tracking

Watch a supplier's public price page for a change in wholesale cost before it hits your next invoice.

MAP compliance checks

Confirm resellers are not advertising below an agreed minimum price by checking their listings on a schedule.

Deal and discount alerts

Get notified the instant a tracked product drops into a target price range for a personal or client watchlist.

FAQ

How often can I check a price with this 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.

Does the price monitoring API handle multiple currencies?

Yes, the extracted price includes the currency as shown on the page, so conversions or comparisons across regions are handled on your side with accurate source data.

Is there a free trial to test price monitoring first?

What if the page shows a sale price and a crossed-out original price?

You can pass a selector or hint pointing at the specific price element you need, so the extraction targets the sale figure rather than an unrelated number on the page.

How do I receive price changes automatically?

Configure a signed webhook and it fires as soon as a comprobación detects a different price than the last recorded value; a signed link valid for 24 hours is also available for manual checks.

Can I monitor prices in bulk across many products?

Yes, each product URL is its own asynchronous task, so you can trigger monitor-price checks across a full catalog from your own scheduler or pipeline.

What happens if the page structure changes and the price can't be found?

The task retries automatically up to three times; if extraction still fails, you receive a clear error instead of a silent or incorrect price, and the failed attempt is not charged.

Is my monitored price data stored long-term?

No, results are kept only through the retention window before deletion, and are never used to train models — they exist solely to deliver your comparison.

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

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

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

Per check$0.001

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.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →