Executive summary
A leadership team doesn't need the whole report — it needs the decision, the number behind it, and the risk if it goes wrong. This executive summary API reads a long document and returns exactly that framing, so the people who have to sign off can do it without reading forty pages 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.
Written for the reader who decides, not the reader who researched
There's a gap between the person who spent three days producing a due-diligence report and the executive who has ten minutes before a board call to approve or reject what's in it. Most summarization just shortens; this endpoint is built specifically to reorganize around what a decision-maker needs — the recommendation, the numbers that justify it, and the risks that could undo it — rather than simply trimming the original text down.
What the call actually does
Send the source document as a POST to /text/executive-summary. Like every task on this API it's asynchronous: you get a task_id immediately, the extraction runs on our infrastructure, and the finished summary is delivered to your signed webhook or made available at a signed link valid for 24 hours. That means a 30-page contract or a full quarterly report can be processed without your application ever waiting on an open connection.
A discipline with real roots
The executive summary as a genre grew out of military briefings and consulting reports, where an officer's or partner's time was scarce and the wrong emphasis could cost lives or clients — so the format evolved specific conventions: lead with the conclusion, quantify wherever possible, name the risk explicitly instead of burying it in a caveat. Those conventions are what this endpoint is trained to reproduce, not a generic shortening of prose.
How it fits into a workflow
This is commonly the last step before a document reaches someone senior: a legal team runs a contract through it before it goes to the CFO, an operations team summarizes an incident postmortem before it reaches the board, an analyst turns a research packet into the one page attached to a decision email. Because it runs async with webhook delivery, it slots into an approval pipeline or document-management system without adding a synchronous bottleneck.
Transparent, usage-based pricing
You're charged a small flat fee per request plus a rate for every 1,000 words processed, both published and predictable in advance. If a summarization attempt fails, it's retried automatically up to three times at no cost to you, and a task that ultimately fails is never billed — you only pay for a summary that was actually delivered.
What you can do with it
Board and investor materials
Condense a full quarterly report or due-diligence packet into the one-page brief attached to a board agenda.
Contract review escalation
Summarize a long legal contract's obligations, figures and risk clauses before it reaches an executive for sign-off.
Incident postmortems
Turn a detailed engineering postmortem into a leadership-facing brief covering what happened, cost and mitigation.
M&A and diligence packets
Reduce a lengthy due-diligence document into the decisions, numbers and risks a deal lead needs before a go/no-go call.
FAQ
How is an executive summary different from a regular summary?
It's structured around decisions, figures and risks rather than just being a shorter version of the source text, matching how leadership actually reads.
Is the executive summary generator 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.
What kind of documents work best?
Reports, contracts, postmortems, due-diligence packets and any long document where a decision-maker needs the conclusion before the detail.
Does it invent numbers or risks not in the source?
No — it extracts and reorganizes what's present in your document; it does not add figures, claims or risks that weren't in the input.
How do I get the result back?
Provide a webhook to be notified when it's ready, or retrieve it from the signed result link, which stays valid for 24 hours.
What happens if generation fails?
The task retries automatically up to three times; if it still fails you get a clear error, and failed tasks are never charged.
Is there a document length limit?
Pricing scales per 1,000 words, so long documents are supported; very large files are best chunked for faster, more reliable processing.
Can I use this alongside the bullet-point or TL;DR endpoints?
Yes, many teams pair a TL;DR for a subject line with an executive summary for the body, since each targets a different reading depth.
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/text/executive-summary \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/executive-summary", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/executive-summary",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/executive-summary", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/executive-summary", 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": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.executive_summary",
"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_tokens | 20000 |
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. |