Key points of a document
Nobody wants to read a forty-page vendor contract to find the three clauses that actually change the deal. This endpoint reads a document and returns its key points, the decisions made, the figures that matter, and the risks worth flagging, so a person can act on a document without reading every paragraph of it first.
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 reading bottleneck this replaces
Long documents create a specific kind of bottleneck: someone qualified has to read the whole thing before anyone can act, and that person's time is usually the most expensive part of the workflow. A procurement lead skimming a supplier agreement, a case manager reviewing a settlement letter, a compliance officer scanning a policy update, all of them are really looking for a handful of sentences buried in pages of boilerplate. This endpoint exists to surface exactly that handful, automatically, so the qualified reader spends their time deciding rather than searching.
What kind of points it pulls out
You send a document to POST /ocr/key-points and receive a task_id right away, since identifying what actually matters in a document takes real reading, not a keyword scan. The result groups findings into practical categories: decisions or commitments stated in the text, figures such as amounts, dates, and quantities that carry weight, and risks or obligations worth a second look, like penalty clauses, deadlines, or unusual terms. You choose how the result reaches you, a signed webhook fired the moment it is ready, or a signed link you fetch within 24 hours.
Why this is judgment, not just summarization
A generic summary compresses a document; key-point extraction is a different task, it filters for what is actionable rather than what is representative. A summary of a contract might mention that it covers payment terms; key points identify the actual net-30 clause and the late-fee percentage, because those are the numbers someone needs to negotiate or approve. That distinction matters most in dense, formal writing, contracts, policy documents, regulatory filings, where the important content is a small fraction of the total text and burying it is often the point of the drafting style.
How it slots into a review workflow
Key-point extraction fits naturally after a classification step, so contracts get read for clauses and risks while invoices get sent to structured extraction instead, and before a human approval step, where the extracted points become the summary someone actually reads before signing off. Because it is cheap per call and stateless, teams often run it on every incoming document as a first pass, reserving full manual review for the documents where the extracted risks warrant it.
Cost built for high-volume reading
Pricing is $0.003 per request plus $0.0135 per page, kept deliberately low because this is meant to run on volume, across every contract or policy a team receives, not just the occasional flagged document. A failed task is never charged, we retry automatically up to three times before returning a clear error explaining what went wrong. There is no free tier or trial, access requires prepaid balance and calls without one return HTTP 402, which keeps the endpoint responsive instead of congested by unpaid traffic.
What you can do with it
Vendor contract review before signing
A procurement team runs every incoming supplier contract through key-point extraction to surface payment terms and penalty clauses before a manager reads the full document.
Insurance policy comparison
A broker extracts the coverage limits and exclusions from several competing policy documents to compare them side by side without reading each one in full.
Regulatory filing triage
A compliance team scans incoming regulatory bulletins for key points to quickly decide which ones require a full legal review.
Settlement and legal correspondence review
A case manager extracts the dollar amounts and deadlines from settlement letters to prioritize which cases need immediate attention.
FAQ
What does the document key points API actually extract?
It pulls out decisions and commitments stated in the text, figures like amounts and dates that carry weight, and risks or obligations worth flagging, such as penalty clauses or deadlines.
How is this different from a document summary?
A summary compresses the whole document; key-point extraction filters specifically for actionable content, the clauses and numbers someone needs to decide or negotiate on.
Is it accurate enough to skip reading the full document?
It is designed to let a qualified reader triage quickly, but for high-stakes decisions we recommend using the extracted points to prioritize which documents get a full read, not as a replacement for legal or contractual review.
Is there a free tier for key point extraction?
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 it cost per document?
It is $0.003 per request plus $0.0135 per page, priced low because the endpoint is built for running across high volumes of documents.
What types of documents work best with this endpoint?
It performs best on dense, formal writing such as contracts, policy documents, and regulatory filings, where important content is a small fraction of the total text.
How do I receive the extracted key points?
You get a task_id immediately, then the result via a signed webhook when ready or a signed link valid for 24 hours.
Can I run it across a large batch of documents automatically?
Yes, each call is independent and billed per document, so it works as a first-pass filter run on every incoming document as well as on a single file.
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/key-points \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input":"…"}'const res = await fetch("https://api.kit.forhosting.com/ocr/key-points", {
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/key-points",
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/key-points", 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/key-points", 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.key_points",
"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. |