Build a timeline from a document
Long documents bury their events out of order — an amendment dated in the appendix, an incident referenced on page two but explained on page nine. This endpoint reads the full document and reconstructs a chronology of dated events as ordered JSON, so you get the sequence of what happened instead of a pile of pages to re-read.
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 problem with dates scattered across prose
A contract mentions a signing date in the header, a renewal clause buried in section 12, and a termination notice referenced only by a letter attached as an exhibit. A litigation file spreads the same story across depositions, exhibits and correspondence, each with its own date format and its own way of referring back to earlier events. Reconstructing the actual order of what happened means reading the whole thing and holding every date in your head at once — exactly the kind of work that doesn't scale past a handful of pages.
Who reconstructs timelines for a living
Litigation paralegals building a chronology exhibit before a hearing, compliance teams tracing when a policy actually changed against when it was communicated, journalists working from leaked document sets, and claims adjusters piecing together the sequence of events in a long incident file all do this same task by hand today, usually with a highlighter and a spreadsheet.
What comes back
Submit the file to POST /ocr/timeline and you get a task_id immediately since the job runs asynchronously. Once processing finishes, the result — an ordered list of events, each with its extracted date, a short description, and a reference to where in the source document it was found — arrives through a signed webhook or waits at a signed link for 24 hours.
Chronology as an old discipline, a new interface
Building a timeline from a mixed record is not a new problem; historians and litigators have done it by hand for as long as archives have existed, cross-referencing dates across letters, ledgers and testimony. What changes here is the speed: a task that once took an afternoon of note cards now returns as structured data before the coffee gets cold, without changing what the underlying reading actually requires.
Fitting it into a review workflow
Because pricing is $0.003 per request plus $0.0135 per page and billing only happens on success, teams route every incoming case file or contract batch through this endpoint as a first pass, then have a person review the generated chronology rather than build one from a blank page. A failed extraction is retried automatically up to three times and never charged; access simply requires prepaid balance, keeping the endpoint fast and free of throwaway traffic.
What you can do with it
Litigation chronology exhibits
A paralegal submits the full case file and gets a dated event list to build a chronology exhibit ahead of a hearing, instead of re-reading every exhibit by hand.
Contract lifecycle review
A legal ops team extracts every dated clause and amendment from a contract to confirm the actual sequence of changes before a renewal decision.
Incident and claims reconstruction
A claims adjuster reconstructs the order of events in a lengthy incident file from mixed correspondence, reports and statements.
Investigative document review
A journalist or researcher processes a leaked or disclosed document set to establish the sequence of events before writing the narrative.
FAQ
What does the Timeline Extraction API return?
An ordered JSON list of dated events found in the document, each with its date, a short description and a reference to where it appears in the source.
How do I call the timeline extraction api?
Send the file to POST /ocr/timeline, receive a task_id right away, and get the chronology by webhook or a signed link once the async task completes.
Is there a free trial for the timeline extraction 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.
How much does timeline extraction cost?
$0.003 per request plus $0.0135 per page, published pricing with no hidden credits, billed only on a successful extraction.
Can it handle documents with inconsistent date formats?
Yes, it reads dates as written across headers, body text and exhibits and normalizes them into the ordered event list.
Does it work on scanned case files or only native PDFs?
Both; it extracts text from scanned pages as well as digital documents before building the chronology.
Am I charged if the extraction fails?
No. A failed task retries automatically up to three times and is never billed; you receive a clear error instead.
Can I process a batch of documents to build one combined timeline?
Submit each document as its own request; you'll get a chronology per document, which you can then merge and sort on your side by date.
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/timeline \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input":"…"}'const res = await fetch("https://api.kit.forhosting.com/ocr/timeline", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"input": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/ocr/timeline",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"input": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/ocr/timeline", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"input":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ocr/timeline", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"input": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "ocr.timeline",
"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. |