Extract product data
A product page hides its real data behind whatever layout the store's theme happened to ship with, and no two themes place the price, stock badge or image gallery in the same spot. This endpoint reads the page the way a shopper does and hands back structured fields — name, price, stock status, images — regardless of which platform or theme built the page.
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.
The problem with a thousand different templates
Every storefront platform, and every theme within it, arranges product information differently: price might sit in a span with a currency symbol baked into the text, stock status might be a colored badge with no underlying text at all, images might load lazily from a carousel that only renders the first frame in raw HTML. A scraper written against one store's markup breaks the moment it hits a different platform, and a catalog spanning dozens of suppliers means dozens of custom parsers to write and maintain. web.product_extract is built to read the page as a shopper would, not as a fixed set of CSS selectors.
What comes back from one product page
POST a product page URL to /web/product-extract and a task_id returns immediately while the page is fetched and interpreted. The finished result includes the product's name, current price, stock or availability status, and the set of product images found on the page, structured the same way regardless of which platform served the original page. Delivery is by signed webhook or a signed link valid for 24 hours, matching how the rest of the platform's async tasks work.
Structured data helps, but isn't always there
Some stores emit clean Product schema in JSON-LD that makes this almost trivial to read; plenty of others don't, or emit it incompletely, leaving price or stock out of the structured markup entirely and forcing a reader back to the visible page itself. A reliable product extraction has to work across both cases — using structured data where it's present and correct, and reading the rendered page directly where it isn't — because a catalog of real-world suppliers will always include both kinds of sites.
Where this fits a catalog or pricing pipeline
A dropshipping catalog syncing prices from supplier pages, a price-comparison tool tracking a product across several retailers, or a purchasing team watching for stock coming back on a component all need the same reliable read on the same handful of fields, repeated across many pages and many stores. Pricing combines a base fee per request with a per-URL charge, so a nightly sync across a thousand product pages costs a predictable, linear amount rather than a flat rate that punishes small catalogs or a metered rate that surprises large ones — and a page that fails to load or genuinely lacks the data is never charged.
What you can do with it
Dropshipping price and stock sync
Pull current price and availability from supplier product pages nightly to keep a storefront's listings accurate without manual checking.
Cross-retailer price comparison
Track the same product's price across several competing stores to power a comparison tool or a repricing strategy.
Back-in-stock monitoring
Watch a component or product page for a stock status change and trigger a purchase or an alert the moment it becomes available.
Catalog enrichment from supplier pages
Fill in missing product images or names in an internal catalog by extracting them directly from the original supplier's page.
FAQ
How do I extract product data with the API?
POST the product page URL to /web/product-extract, keep the returned task_id, and collect the structured product data by webhook or a signed link valid for 24 hours.
Is the product data extraction API free?
No, there is no free tier or trial; it costs $0.046 per request plus $0.0145 per URL, and a failed extraction is never charged.
What fields does it return?
Product name, current price, stock or availability status, and the images found on the page, structured consistently across different stores and platforms.
Does it work on any e-commerce platform?
It's built to read pages generically rather than target one platform, combining structured Product schema where available with direct page reading where it isn't.
How accurate is the price and stock data?
It reflects exactly what the page showed at the moment of extraction; prices and stock that change frequently should be re-checked on whatever schedule matches how often the source page updates.
Can I extract data from thousands of product pages in bulk?
Yes, submit one async task per URL and collect each result by webhook, which is how catalog-scale syncs are typically built.
What happens if a page has no visible price or stock info?
The task returns whatever fields it could confidently extract and leaves the rest empty rather than guessing at a value.
Is the page content stored after extraction?
No, fetched pages and extracted product data are deleted after the retention window and are 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
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/product-extract \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://ejemplo.com"}'const res = await fetch("https://api.kit.forhosting.com/web/product-extract", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://ejemplo.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/product-extract",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/product-extract", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://ejemplo.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/product-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://ejemplo.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.product_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. |