Extract contract data
Upload a signed agreement and get back who the parties are, when it takes effect and expires, the amounts involved and how it renews, each as a separate detail. Which supplier contracts renew next quarter becomes a quick search. 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.
Contracts bury their operative facts inside pages of standard clauses that nobody rereads once they're signed.
Why contract data goes missing
A contract is binding the moment it is signed, yet the facts inside it become practically invisible once it is stored as a scan or a PDF. The parties, the dates and the money are buried in pages of standard clauses nobody rereads. A legal team, a finance department or a purchasing office rarely needs to reread the whole thing; they need to know who signed, when it expires and how much is involved. This tool reads the contract like a paralegal on a first pass and returns the parties, the effective and expiry dates, the amounts and the renewal terms as separate details.
What teams do with the result
Legal teams fill their contract register automatically as agreements are signed, instead of typing each one in. Finance teams pull amounts and payment terms to check them against invoices and purchase orders. Purchasing teams flag which supplier agreements are approaching renewal or termination across the whole portfolio. During an acquisition or an audit, key terms from hundreds of contracts can be reviewed quickly. It is built for agreements; for invoices or identity documents, the dedicated readers fit better.
Contracts are old, but the extraction problem is new
Written contracts predate the printing press, but the practice of storing thousands of them as scanned images and PDFs is entirely a byproduct of the last few decades of digitization, and it created a specific new problem: a contract's terms are legally binding the moment it's signed, yet the data inside it becomes functionally invisible unless someone manually retypes it. Structured extraction is the missing bridge between the signed document and the systems that need to act on it.
What you can do with it
Contract repository population
Automatically extract party names, dates and amounts as signed agreements are uploaded, instead of manual data entry into a CLM system.
Renewal and expiry tracking
Scan an entire vendor contract portfolio to flag which agreements are approaching their renewal or termination date.
Finance and payment reconciliation
Pull monetary amounts and payment terms from signed contracts to cross-check against invoices and purchase orders.
Due diligence document review
Extract key terms from hundreds of contracts quickly during an acquisition or audit instead of reading each one manually.
FAQ
What fields does the contract data extraction api return?
Parties, effective and expiry dates, monetary amounts, and key terms such as renewal or termination conditions.
Is there a free version of the contract 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.
Is a failed contract extraction billed?
No. Failed tasks are retried automatically up to three times and are never charged if they still fail.
Does it work on scanned paper contracts?
Yes, it extracts data from scanned pages as well as native digital documents.
How can I see which contracts renew next quarter?
Run your signed contracts through the extraction and each one comes back with its expiry date and renewal terms as separate details. Sort or filter that list by date and the answer takes seconds instead of an afternoon of searching folders.
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/contract \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"El informe trimestral cerró con 1,2 M€ de ingresos."}'const res = await fetch("https://api.kit.forhosting.com/ocr/contract", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "El informe trimestral cerró con 1,2 M€ de ingresos."
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/ocr/contract",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "El informe trimestral cerró con 1,2 M€ de ingresos."
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/ocr/contract", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"El informe trimestral cerró con 1,2 M€ de ingresos."}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"El informe trimestral cerró con 1,2 M€ de ingresos."}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ocr/contract", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "El informe trimestral cerró con 1,2 M€ de ingresos."
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "ocr.contract",
"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 extracts what a paralegal would flag on a first pass — the parties, effective and expiry dates, monetary amounts, renewal terms — so that contract data can live in a database instead of a filing cabinet.
The problem of a signed contract nobody can query
A legal team, a finance department or a procurement office rarely needs to reread a whole contract; they need to know who signed it, when it expires, and how much money is involved, right now, without opening the PDF. This endpoint solves exactly that: it reads the contract and returns the operative facts as structured fields, so answering 'which vendor contracts renew next quarter' becomes a database query instead of an afternoon of searching folders.
What happens after you submit the document
You send the file to POST /ocr/contract and receive a task_id immediately, because extraction runs asynchronously and can take longer on lengthy multi-page agreements. Once processing finishes, the structured result — parties, dates, amounts, key terms — is delivered through a signed webhook, or made available at a signed link valid for 24 hours.
How it fits into a document workflow
Legal operations teams use it to populate a contract repository automatically as agreements are signed; finance teams use it to catch payment amounts and due dates without manual review; procurement teams use it to flag contracts approaching renewal or expiry across an entire vendor portfolio, all without anyone reading each contract cover to cover.
Pricing tied to document length
The endpoint charges $0.003 per request plus $0.0135 per page, reflecting that a ten-page agreement takes more work to extract than a one-page addendum; you're only billed once extraction succeeds, and a failed attempt is retried automatically up to three times before returning a clear error with no charge. Access is gated by prepaid balance rather than a free tier, which keeps processing capacity available for real work.
Technical questions
How is pricing calculated for long contracts?
You pay $0.003 per request plus $0.0135 per page, so cost scales with the length of the document you submit.
How do I retrieve the extracted contract data?
Through a signed webhook when the task completes, or from a signed link that remains valid for 24 hours.
Can it process multi-page contracts?
Yes, the endpoint reads the full document and prices per page, handling lengthy multi-page agreements as a single async task.
Can I run bulk contract extraction across a whole portfolio?
Yes, submit each contract as its own request; every call returns its own task_id so a full portfolio can process concurrently.