Turn handwriting into text
The Handwriting OCR API reads handwritten notes, filled-out forms, and cursive script from an image and converts them into text you can store, search, or route into a system. It's built for the specific difficulty printed-text OCR wasn't designed to solve: no two people write a letter the same way twice.
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.
Why handwriting is a different problem
Printed text has a finite set of consistent letterforms; handwriting doesn't. The same word looks different depending on who wrote it, how fast, and with what pen, and even a single writer's letters shift shape from one sentence to the next. Recognizing handwriting has historically lagged behind recognizing print for exactly this reason, which is why treating it as a distinct problem — rather than reusing a printed-text engine — is what the handwriting ocr api exists to do.
What the service reads
You submit an image containing handwriting — a filled-in form, a page of notes, a signed field, a doctor's note, a survey response written by hand — and the service analyzes the strokes to recognize what was written, returning the result as plain text tied to the image you sent. Print and cursive both fall within scope, though legibility still matters here the way it would for a human reader: faint pencil or genuinely illegible scrawl is a harder case than clear pen strokes, and results should be reviewed for anything where accuracy is critical.
The request-to-result cycle
A call to POST /ocr/handwriting hands back a task_id immediately rather than making you wait on an open connection while recognition runs. Once it's done, you're notified by a signed webhook — the natural choice for a form-processing pipeline handling submissions continuously — or you fetch the transcription through a signed link valid for 24 hours, when you just need one result on demand.
Where it fits in a workflow
This is built for the moment paper still shows up in an otherwise digital process: patient intake forms filled out by hand, paper surveys collected in the field, handwritten inventory tags, or notes scribbled during an inspection that need to become searchable records. Because each image is one async request, a clinic digitizing a stack of intake forms and a field team submitting one photo at a time both use the same call, just at different volume.
Pricing and how errors are handled
The rate is $0.010 per request plus $0.0575 per image, published and flat regardless of how much text is on the page. An image the service can't process is retried three times before returning a clear error, and a failed task is never billed, so cost only accrues for handwriting actually transcribed. Access requires prepaid balance — no free tier or trial — which keeps the endpoint fast and abuse-free; requests without balance return 402. Images and transcriptions are deleted after the retention window and never used for training.
What you can do with it
Digitizing patient intake forms
A clinic photographs handwritten intake forms and gets back structured text instead of manually re-keying patient information into the system.
Field survey collection
A research team collects handwritten paper surveys and transcribes them in bulk, turning field data into a searchable dataset without manual entry.
Handwritten inventory tags
A warehouse converts photos of handwritten stock tags into text entries, closing the gap between a paper-based floor process and a digital inventory system.
Inspection and site notes
An inspector's handwritten notes from a site visit are photographed and transcribed into text that gets attached directly to the digital report.
FAQ
How do I convert handwriting to text with an API?
Send an image containing handwriting to POST /ocr/handwriting and you get a task_id back immediately. The handwriting ocr api recognizes the text asynchronously and delivers it by signed webhook or a signed link valid 24 hours.
Is the handwriting OCR API free?
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.
Does it handle cursive as well as print handwriting?
Yes, both are within scope, though legibility still affects results the way it would for a human reader — clear pen strokes recognize more reliably than faint pencil or genuinely illegible scrawl.
How accurate is handwriting recognition compared to printed text?
Handwriting is inherently harder to recognize than print because letterforms vary from writer to writer, so results for anything accuracy-critical, like signed legal fields, should still be reviewed.
Can I process a batch of handwritten forms at once?
Yes. Each image is an independent async request with its own task_id, so a stack of forms can be submitted as a batch and results collected as they finish.
What happens if the API can't read an image?
It's retried three times automatically before returning a clear error, and a failed task is never charged, so cost only reflects handwriting actually transcribed.
What image quality does handwriting OCR need?
A clear, reasonably lit photo or scan works best; the service is designed to tolerate typical photo conditions but genuinely faint or illegible writing remains hard to recognize.
How long is the transcribed text available?
The signed link stays valid for 24 hours, or you can get it immediately via signed webhook; after the retention window both image and text are deleted and 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/ocr/handwriting \
-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/handwriting", {
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/handwriting",
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/handwriting", 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/handwriting", 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.handwriting",
"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. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |