Read a barcode from a photo
A dedicated handheld scanner reads a barcode instantly because it's built for exactly one job under exactly one kind of lighting; a phone camera photographing a crumpled receipt or a dented can has none of those guarantees. This barcode scanner api reads EAN, UPC, Code128, Code39 and ITF codes from an ordinary photo, so applications that only have a camera, not a laser scanner, can still pull a reliable product code out of an image.
This task is not available right now, so it cannot be purchased. Nothing is charged for it.
How it works & APIWhy photographed barcodes are harder than they look
A dedicated retail scanner sweeps a laser or takes a controlled image at a fixed distance and angle, conditions a barcode format was designed around from the start. A photo taken by hand introduces skew, uneven lighting, motion blur and, on curved packaging like a can or bottle, actual geometric distortion of the bars themselves. Decoding from that kind of image means correcting for all of it before the bar widths can even be measured accurately enough to read the underlying digits.
What POST /dev/barcode-decode does with your image
You send a photo containing one or more barcodes, and the task locates each symbol, determines which symbology it's using, and returns the decoded value along with the format it identified. If a code is too damaged, too small, or too distorted to decode reliably, the task reports that outcome explicitly instead of guessing at a value that might be wrong.
Fifty years of the same underlying idea
The commercial barcode dates to 1974, when the first UPC-coded item was scanned at a real checkout counter, and the core mechanism, bars and spaces of varying width representing digits, hasn't fundamentally changed since. What has changed is how those codes get read: a job that once required a dedicated, expensive laser unit can now be done from a general-purpose camera image, which is precisely what makes decoding from an ordinary photo practical today in a way it wasn't a generation ago.
Distinguishing symbologies automatically
EAN, UPC, Code128, Code39 and ITF each encode their data with a different bar pattern and structure, and the task identifies which one it's looking at as part of decoding rather than requiring you to specify it in advance. That matters in practice because a single photo, of a shipping carton for example, might contain an ITF code on the outer box and a Code128 label from a carrier stuck next to it, and both need to be read correctly without manual sorting.
How it fits an automated intake workflow
Inventory audits done with a phone camera instead of a handheld scanner, returns processing that photographs a product to confirm its identity, and customer-facing apps that let a shopper scan a price tag to compare it elsewhere all call this endpoint the same way, sending an image and receiving the decoded value through a signed webhook or a signed link. A batch of photos from a single audit run processes through the same asynchronous model as a single image.
What you can do with it
Phone-based inventory audits
Photograph shelf stock with a standard phone camera and decode each product's barcode without carrying a dedicated handheld scanner.
Returns processing verification
Confirm a returned item's identity by decoding the barcode on its packaging against the original order before issuing a refund.
Price comparison in a shopping app
Let a user photograph a price tag's barcode so the app can decode the product code and look up pricing elsewhere.
Mixed-symbology shipping label reads
Decode both the ITF code on an outer carton and a Code128 carrier label appearing in the same photo during dock intake.
FAQ
Which barcode types does this barcode scanner api read?
EAN, UPC, Code128, Code39 and ITF, with the symbology identified automatically as part of decoding.
Can it decode a barcode from a curved surface like a can?
Yes, within reasonable limits, the decoder is built to handle the distortion typical of barcodes printed on curved packaging photographed by hand.
What happens if the barcode is too damaged to read?
The task reports explicitly that the code couldn't be decoded reliably rather than returning a guessed or incorrect value.
Do I need to tell the API which symbology to expect?
No, the symbology is identified automatically as part of decoding, so you don't need to specify EAN, UPC, Code128, Code39 or ITF in advance.
Can I decode multiple barcodes from one photo?
Yes, each barcode found in the image is decoded and returned separately, including cases where different symbologies appear in the same photo.
Is there a free tier for scanning barcodes?
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.
How much does decoding a barcode cost?
$0.002 per request plus $0.005 per image, with no charge for a task that ultimately fails after retries.
How do I receive the decoded result?
POST /dev/barcode-decode returns a task_id immediately, and the decoded value is delivered via signed webhook or a signed link valid for 24 hours.
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/dev/barcode-decode \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"image":"https://ejemplo.com/imagen.jpg"}'const res = await fetch("https://api.kit.forhosting.com/dev/barcode-decode", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"image": "https://ejemplo.com/imagen.jpg"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/barcode-decode",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"image": "https://ejemplo.com/imagen.jpg"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/barcode-decode", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"image":"https://ejemplo.com/imagen.jpg"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"image":"https://ejemplo.com/imagen.jpg"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/barcode-decode", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"image": "https://ejemplo.com/imagen.jpg"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.barcode_decode",
"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.
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. |