ForHosting KIT · OCR & Data Extraction

Get the data behind a chart

A chart published as a static image locks its numbers away the moment the file is exported, and there is no undo button hidden in a PNG. This endpoint looks at that image and reconstructs the series behind it, giving you back axis labels, categories and values as data you can actually recalculate with.

● BetaPer request + per image$0.010

Run — $0.010 + $0.0575/image 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 one-way trip most charts take

A chart usually starts life as real numbers in a spreadsheet or analytics tool, gets rendered once, and is then shared as a flattened image in a report, a slide deck or a scanned annual filing. From that point on the underlying values are gone unless someone tracks down the original file. This endpoint reverses that last step by reading the visual chart and recovering the data it was built from.

What kinds of charts it reads

It is built around the chart types that dominate business reporting: bar charts, line charts and pie charts, whether hand-drawn in a slide tool or exported from analytics software. For each one it identifies the axis labels or category names, the legend if present, and the numeric value tied to every bar, point or slice, returning them as a structured series rather than a redrawn picture.

Where precision comes from and where it doesn't

Reading values off a rendered image is fundamentally an estimation problem, not a database lookup: the endpoint infers the closest numeric value each mark represents based on its position against the axis. Charts with clear gridlines, printed data labels or a well-defined scale extract more reliably than a low-resolution screenshot of a chart with no labeled axis at all, so image quality and chart design both matter to the result.

The mechanics of the call

Post the chart image to POST /ocr/chart and you get a task_id back immediately, since the extraction runs asynchronously. The finished data lands via your signed webhook, or you can pull it from a signed link that remains valid for 24 hours, and a chart that can't be resolved after three internal attempts returns a clear error with no charge attached.

Turning old reports into live data

Analysts use this to rebuild a competitor's published growth chart into a comparable spreadsheet, researchers pull numeric series out of figures in older PDFs that never shipped with a data appendix, and internal tooling pipelines feed scanned quarterly decks through it to recover metrics nobody re-exported before archiving.

What you can do with it

Competitive benchmarking from published reports

A market analyst extracts the yearly revenue figures behind a competitor's bar chart from an investor presentation instead of eyeballing the bars.

Digitizing figures from academic PDFs

A researcher pulls the numeric series from a line chart in an older paper that never published its underlying dataset.

Recovering metrics from archived slide decks

An operations team runs old quarterly review slides through the endpoint to rebuild a historical KPI spreadsheet that was never saved.

Auditing a pie chart breakdown

A finance reviewer converts a budget-allocation pie chart from a scanned report into percentages they can recompute and cross-check.

FAQ

What does a chart data extraction API actually return?

It returns the axis labels, categories and numeric values behind a bar, line or pie chart image as structured data, not a redrawn image.

Is it free to use?

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's the price?

$0.010 per request plus $0.0575 per image, and you're only billed for tasks that complete successfully.

Which chart types are supported?

Bar charts, line charts and pie charts are the primary supported types, covering most charts found in business and analytics reporting.

How accurate are the extracted numbers?

Values are estimated from each mark's position relative to the axis, so charts with visible gridlines or printed data labels extract more reliably than low-resolution images with no scale.

How is the result delivered?

Call POST /ocr/chart to receive a task_id right away, then get the structured data via a signed webhook or a signed link valid for 24 hours.

What if the chart image is too small or blurry to read?

The system retries up to three times internally, and if the chart still can't be resolved you get a clear error instead of being charged.

Can I process a batch of chart images?

Yes, each chart image is its own asynchronous task, so you can submit many at once and collect each result as it finishes.

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/ocr/chart

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

const res = await fetch("https://api.kit.forhosting.com/ocr/chart", {
  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/ocr/chart",
    headers={"Authorization": f"Bearer {os.environ[&#39;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/ocr/chart", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"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/ocr/chart", 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": "ocr.chart",
  "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.010

Per image$0.0575

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	25
`max_pages`	10

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 →