Read a filled-in form
Photograph a completed intake sheet and every answer comes back next to its label: typed text, handwriting, a ticked box, an X or a circled option, all read question by question. Nobody retypes the stack. Pay per use, 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.
A filled-out paper form is exactly the kind of document computers were supposed to have retired years ago, yet intake desks, clinics and government offices still run on them.
Why a simple form is hard to read
A form looks simple next to a contract, but it is surprisingly demanding to read well. Handwriting varies wildly from one person to the next. A ticked box can be a check mark, an X, a filled square or a circled option, depending on who filled it in. And the same form photographed at an angle looks nothing like its scanned twin. Plain text recognition over the whole page returns an undivided block of words. This tool reads the form as a set of questions instead: it finds each label, reads what was written or typed beside it, interprets ticked boxes and chosen options, and returns every answer tied to its label.
Where paper forms still arrive
Many processes went digital long ago, but the moment of collecting the information often stayed on paper, because asking everyone to use a screen is not always realistic. Clinics turn handwritten intake sheets into records without a clerk retyping them. Offices read applications handed in at a counter. Researchers turn a pile of paper surveys, comments included, into a table ready for analysis. Insurers pull policyholder details and ticked options from claim forms. For identity cards or purchase orders, the dedicated readers fit better.
Why forms are harder than they look
A form looks simple compared to a contract or a resume, but it's deceptively demanding to parse well: handwriting varies wildly from one respondent to the next, a checkbox can be a checkmark, an X, a filled square or a circled option depending on who filled it in, and the same form template photographed at an angle looks nothing like its scanned twin. Reading a form reliably means handling that inconsistency at the field level, not just running text recognition over the whole page.
What you can do with it
Patient intake digitization
Convert handwritten patient intake sheets from a clinic's front desk into structured records without manual data entry.
Government application processing
Read paper applications submitted at a counter into a database, replacing manual re-keying by office staff.
Market research survey capture
Turn a stack of paper survey responses, including checkboxes and handwritten comments, into a spreadsheet ready for analysis.
Insurance claim form intake
Extract policyholder information and checked options from scanned claim forms to speed up initial claim triage.
FAQ
Can the form data extraction api read handwriting?
Yes, it interprets handwritten entries as well as printed text and checked boxes, returning each answer tied to its field.
What file types can I submit?
Scanned pages and photographs of filled paper forms, as well as native digital form documents.
Is there a free tier for the form data extraction api?
There's no free tier — free tiers get abused and slow everyone down. No subscription, no tokens, no invented credits, and a failed task is never charged.
Am I charged if the form fails to process?
No. Failed tasks are retried automatically up to three times and are never billed if they still fail.
Does it handle checkboxes and selected options?
Yes, it interprets checkmarks, X marks, filled boxes and circled selections as part of each field's answer.
Can I process multi-page forms in bulk?
Yes, pricing is per page and each submission runs as its own asynchronous task, so large batches process concurrently.
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/ocr/form \
-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/ocr/form", {
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/form",
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/ocr/form", 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/ocr/form", 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.form",
"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
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. |
413 | input_too_large | The file exceeds the size limit. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |
Technical notes
This endpoint reads a scanned or photographed form field by field — printed text, handwriting, checked boxes — and returns the answers as structured JSON instead of a flat image.
The last mile that stayed on paper
Plenty of processes went digital decades ago, but the actual point of data capture — a patient intake sheet, a survey filled out at a kiosk, a government application completed by hand at a counter — often stayed stubbornly on paper, because forcing every person filling it out onto a screen isn't always realistic. This endpoint exists for that last mile: it takes the paper form as it was actually completed and turns it into data without asking anyone to retype it.
What the endpoint actually reads
Unlike a generic OCR pass that returns undifferentiated text, this endpoint understands the form as a set of fields: it locates labels, reads what was written or typed next to them, interprets checked boxes and selected options, and returns each answer tied to its field name. Send the scanned or photographed form to POST /ocr/form, get a task_id immediately, and receive the structured answers through a signed webhook or a signed link valid for 24 hours once processing finishes.
Where automated form reading pays off
Clinics and hospitals use it to digitize patient intake sheets without a data-entry clerk retyping every field; government and municipal offices use it to process paper applications submitted at a counter; market research firms use it to turn a stack of paper survey responses into a spreadsheet ready for analysis, all without redesigning the form or asking respondents to change how they fill it out.
Pricing reflects the field-level work involved
This endpoint costs $0.010 per request plus $0.0575 per page, higher than plain text extraction because reading discrete fields, handwriting and checkboxes accurately is genuinely more work; you're billed only when a form is successfully processed, and a failed attempt is retried automatically up to three times before returning a clear error at no charge. There's no free tier or trial — access requires prepaid balance, which keeps the endpoint fast and reserved for real submissions.
Technical questions
Why does form extraction cost more than plain text extraction?
Reading discrete fields, handwriting and checkboxes accurately requires more processing than extracting flat text, which is reflected in the $0.010 per request plus $0.0575 per page price.
How do I receive the extracted form data?
Through a signed webhook when the task completes, or from a signed link that stays valid for 24 hours.