ForHosting KIT · Web Scraping & Monitoring

Check if it's in stock

A product can look available in a search result and be sold out by the time a customer clicks through. This stock availability API loads the actual page and reads the same signal a shopper sees — in stock, out of stock, low stock, or backordered — returning it as a clean status you can act on immediately.

● StablePer request + per URL$0.046

Run — $0.046 + $0.0145/URL How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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 gap between a catalog and reality

Inventory feeds and internal databases go stale the moment a warehouse ships the last unit, and a lot of storefronts never expose a clean inventory count anyway — they show a badge, a button state, or a sentence buried in the page copy instead. The stock-extract endpoint reads the page the way a human shopper would, picking up whatever signal the store actually renders rather than assuming a feed is accurate.

How a request flows

You call POST /web/stock-extract with the product URL, get a task_id back immediately, and the task resolves asynchronously. The response classifies availability — typically in stock, out of stock, limited quantity, or preorder/backorder — along with whatever supporting text the page provided, delivered by signed webhook or a signed link valid for 24 hours.

Where availability checks matter most

Dropshippers need to know before a customer orders that the supplier can actually fulfill it, since a cancelled order after payment damages trust fast. Price comparison sites lose trust the moment they send shoppers to a sold-out listing. Retail teams launching a restock want to know the instant a competitor's inventory returns so they can time a promotion. In every case, the cost of checking manually scales with the number of products being watched, while an automated API call does not.

Why availability signals aren't standardized

Unlike price, which at least has a common schema.org convention, stock status has never settled on one universal format across storefronts — some use a boolean in structured data, others only communicate it through a disabled 'Add to cart' button or a short phrase like 'ships in 3 weeks.' That inconsistency is exactly why a page-rendering approach outperforms a purely structured-data lookup for this particular signal.

Running it on a schedule

Because failed checks are never billed — three retries before a clear error — this endpoint is well suited to frequent polling of a watchlist of products without worrying about wasted spend on pages that momentarily fail to load. Combine it with a webhook to notify a team or trigger a reorder the moment stock status flips.

What you can do with it

Restock alerts for shoppers

A niche retailer watches a supplier's product page and notifies its own waitlist the moment the item reads as back in stock.

Dropshipping reliability checks

A dropshipping operation verifies supplier stock before confirming an order to a customer, avoiding cancellations after the sale.

Comparison site accuracy

A price comparison platform filters out listings that currently show as out of stock so shoppers aren't sent to dead links.

Competitive inventory watching

A brand tracks when a limited-edition item goes out of stock at a competitor to time its own marketing push.

FAQ

How accurate is a stock availability check on a scraped page?

It reflects exactly what the storefront currently displays to a visitor, which is the same information a real shopper would see at that moment.

Is there a free tier for the check stock availability 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 stock availability API cost?

It's $0.046 per request plus $0.0145 per URL, charged only for tasks that complete successfully.

Can it detect low-stock warnings, not just in-stock or out-of-stock?

Yes, when the page itself shows a low-stock message or limited-quantity notice, that detail is captured in the response.

Can I check stock on many products in bulk?

Yes, submit multiple product URLs and each is processed and billed individually at the per-URL rate.

What if the page temporarily fails to load?

The task retries automatically up to three times before returning a clear error, and you're never charged for a failed attempt.

How do I receive the availability result?

Via a signed webhook, which we recommend for automated flows, or a signed link that remains valid for 24 hours.

Does it work on preorder and backorder pages?

Yes, preorder and backorder states are reported as distinct statuses from a plain out-of-stock result.

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/stock-extract

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/stock-extract \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"url":"https://ejemplo.com"}'

const res = await fetch("https://api.kit.forhosting.com/web/stock-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/stock-extract",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/stock-extract", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"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/stock-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.stock_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

Per request$0.046

Per URL$0.0145

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 →