Extract a price
Point it at a product page and get back the price a buyer would actually pay, with its currency, plus the struck-through original price and the discount when the page shows them. Prices that appear after the page loads are read too. You pay per use, with no subscription.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
Prices on the web move without warning, and every store hides them in a different corner of the HTML.
Why a price is harder to read than it looks
On most product pages the price is not a single number. A struck-through list price sits next to a highlighted sale price, a currency selector changes the figure, and many stores only draw the price after the page has finished loading. Copying the page text picks up the wrong number, and a hand-written rule that worked yesterday breaks as soon as the store redesigns its layout. The tool opens the page the way a browser does and keeps only the price a real buyer would act on, together with its currency.
Who uses it and what to keep in mind
Online stores check rival product pages each morning and adjust their own prices. Marketplaces confirm that the price a seller typed in matches what the seller's own storefront shows. Deals blogs refresh the prices in published articles instead of leaving stale figures online for weeks, and purchasing teams watch supplier catalogs to catch increases before the next invoice arrives. Bear in mind that the original price and the discount only come back when the page actually shows them; when a store lists a single figure, that is the price you get.
Why prices are harder to read than they look
A price is rarely just a number. Pages mix a struck-through list price with a highlighted sale price, hide the real total behind a currency selector, or render the figure with JavaScript after the initial page load. Anyone who has tried to regex a price out of raw HTML knows how quickly that breaks the moment a store redesigns its template.
What you can do with it
Competitor price monitoring
An e-commerce team feeds in a list of rival product URLs each morning and updates its own pricing rules based on the returned figures.
Marketplace listing audits
A marketplace checks that the price a third-party seller entered matches what actually renders on the seller's own storefront.
Affiliate content accuracy
A deals blog refreshes displayed prices on published articles automatically instead of leaving stale figures live for weeks.
Procurement cost tracking
A purchasing team monitors supplier catalog pages to catch price increases before the next invoice arrives.
FAQ
Can I submit multiple product URLs in one request?
Yes, batch multiple URLs into a single task and each is priced individually at the per-URL rate.
What happens if a product page fails to load?
The task retries automatically up to three times; if it still fails you receive a clear error and are not charged.
Does it work on pages that load prices with JavaScript?
Yes, the page is rendered before extraction, so prices injected dynamically after load are captured correctly.
Is my scraped pricing data used to train any models?
No. Data is deleted after the retention period and is never used for training.
Does it tell the sale price apart from the crossed-out list price?
Yes. The main figure is the current price a buyer would act on and, when the page shows them, the original price and the discount come back separately, so a promotion is never mistaken for the regular price.
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
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/price-extract \
-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/price-extract", {
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/price-extract",
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/price-extract", 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/price-extract", 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.price_extract",
"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 extraction API opens a product page, finds the actual price a shopper would see, and hands it back as structured JSON you can drop straight into a spreadsheet, a repricer, or a database.
Why prices are harder to read than they look
The price-extract endpoint is built specifically for this mess: it renders the page the way a browser would, then isolates the price a real buyer would act on.
What you send and what comes back
You submit one or more product URLs to POST /web/price-extract. Each task runs asynchronously and returns a task_id immediately, so your integration never sits there waiting on a slow page load. When the extraction finishes, you get the current price, the currency, and — when the page exposes it — the original price and any discount, delivered by signed webhook or through a signed link that stays valid for 24 hours.
Who actually needs this
Retailers watching competitor pricing, marketplaces validating seller-submitted prices, affiliate sites keeping listings honest, and finance teams tracking supplier costs all run into the same wall: prices change constantly and manual checking does not scale. This endpoint replaces the person who used to open forty tabs every morning with a single API call that can be scheduled as often as the business needs.
A brief note on how prices got messy
In practice, a large share of storefronts either omit that markup, get it wrong, or override it visually with promotional pricing that the metadata never reflects — which is why relying on markup alone leaves gaps that a full page render closes. Structured price markup has existed for years through schema.org and Open Graph tags, and where a page publishes it correctly, extraction is fast and precise.
Fitting it into a pipeline
Because every request is billed only on success — three automatic retries, then a clear failure with no charge — you can wire this endpoint into a nightly monitoring job or an on-demand pricing check without worrying about paying for pages that fail to load. Pair it with a webhook receiver and the whole price-tracking loop runs unattended.
Technical questions
How does the price scraping API handle sale prices versus list prices?
It returns the current price a shopper would pay, and separately reports the original list price and discount when the page exposes that information.
Is there a free tier for the price extraction 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.
What does the price extraction API cost?
It's $0.046 per request plus $0.0145 per URL processed, billed only when the task succeeds.
How do I get the result — webhook or polling?
Results are delivered via signed webhook, which we recommend, or through a signed link that stays valid for 24 hours.