Track a price
Point it at a competitor's or supplier's product page and get told when the price moves, read the way a shopper sees it, even when a crossed-out original sits next to a sale price. You choose hourly or daily checks. You pay per check, with no subscription.
Prices move faster than any human can watch a page, especially when a competitor runs flash discounts or a supplier adjusts costs overnight.
Why prices are hard to watch by hand
Prices move faster than anyone can watch a page, especially when a competitor runs flash discounts or a supplier adjusts costs overnight. Retailers repricing against competitors, marketplace sellers tracking a supplier's cost and procurement teams watching a vendor's list price share the same problem: the number they need lives on a page nobody has time to check several times a day across dozens or hundreds of products. A stale price feeding a repricing rule can quietly cost margin. Price watching is as old as retail, from sending someone down a competitor's aisle with a notepad to today's prices that change by algorithm, often outside business hours.
What the monitor reads and when it speaks up
Each check reads the price and currency the way a shopper sees them. When a page shows several figures, such as a crossed-out original next to a sale price, the monitor understands the page instead of relying on a fixed position. The result is compared with the last recorded value for that page, and a change is flagged only when the number moved. You decide how often to check: hourly for volatile categories, daily for stable ones. Typical uses are feeding a rival's price into your own repricing rules, spotting a supplier's cost change before the next invoice, confirming that resellers respect an agreed minimum price and getting an alert when a product enters a target range.
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.
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.
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
Is there a free trial to test price monitoring first?
There's no free tier — free tiers get abused and slow everyone down. No subscription, no tokens, no invented credits, and a failed task is never charged.
What if the page shows a sale price and a crossed-out original price?
The extraction reads the page the way a shopper would, so it targets the main advertised price rather than a crossed-out original or an unrelated number — there's no CSS selector to configure.
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.
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-price \
-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-price", {
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-price",
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-price", 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-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
{
"url": "https://example.com"
}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
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. |
Technical notes
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.
How the extraction works
The task fetches the page, reads the current price and currency the way a shopper would see them — sorting out pages that show multiple prices, like a strikethrough original next to a sale figure, by understanding the page rather than a fixed HTML position — and compares it against the last recorded value for that URL, flagging a change when the number moved. A call to POST /web/monitor-price takes a URL.
Fitting into a pricing pipeline
Scheduling the checks themselves is yours to control, whether that means hourly for volatile categories or daily for stable ones. 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.
What it costs and what it does not
Failed extractions retry automatically up to three times and are never billed if the task ultimately fails. The base cost is $0.040 per request plus $0.001 per check, 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.
Technical questions
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.
How do I receive price changes automatically?
Configure a signed webhook and it fires as soon as a check detects a different price than the last recorded value; a signed link valid for 24 hours is also available for manual checks.