TL;DR
One sentence, honestly earned — not a teaser, not a tagline, an accurate compression of what the text actually says. This TL;DR generator API takes long input and returns the single line that tells a reader whether the rest is worth their time.
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 internet's most useful three letters
'Too long; didn't read' started as an admission of laziness on forums and became, over time, something closer to a genre convention: a courtesy the writer offers the reader up front. A good TL;DR isn't a summary shrunk further — it's a different exercise entirely, forcing a single claim to carry the weight of the whole piece. This endpoint automates that exercise for whatever text you throw at it, from a support thread to a whitepaper.
How the request behaves
Call POST /text/tldr with your source text and you'll get a task_id back immediately — generation happens asynchronously so a long document never ties up your request thread. The finished one-liner arrives at your signed webhook the moment it's ready, or you can retrieve it from a signed link that remains valid for 24 hours if you'd rather pull it than have it pushed to you.
Harder than it looks
Compressing an argument to one sentence forces real choices: which claim is load-bearing and which is supporting detail, which nuance can survive being cut and which can't. That's a different skill from ordinary summarization, closer to writing a strong newspaper headline than to abridging a chapter, and it's why this is its own endpoint rather than just the shortest setting on the general summarizer.
Where a single line earns its keep
Email subject lines, push notification text, the preview line under a search result, a Slack digest of ten articles where nobody has time for more than a sentence each — anywhere space is measured in characters rather than paragraphs, a well-made TL;DR does the job a full summary can't. It's also useful upstream of a human: as a fast way to see whether a document needs the executive summary treatment at all.
Simple, published pricing
Each request costs a small flat fee plus a rate per 1,000 words of input, published and not hidden behind tiers. Failed generations are retried automatically up to three times and are never billed if they ultimately fail — you're only charged for a TL;DR that was actually delivered to your webhook or link.
What you can do with it
Email subject lines
Generate an accurate one-line subject from a long email body instead of relying on the first sentence, which often isn't the point.
Push notification copy
Compress an article or update into the single line that fits a mobile notification's character limit without losing the point.
Digest and newsletter previews
Produce the one-sentence preview shown next to each item in a roundup of ten or more articles.
Triage before deeper reading
Get the one-line gist of an incoming document to decide fast whether it needs a full read or the executive summary endpoint.
FAQ
How long is the TL;DR the API returns?
One sentence by design — that's the point of the endpoint, distinct from the shorter multi-sentence output of the general summarizer.
Does the TL;DR generator API have a free trial?
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.
Can the TL;DR be misleading or clickbait?
No — it's built to compress accurately, not to tease. It reflects the actual content of the text, not an exaggerated hook.
What input format is accepted?
Plain text in the request body. For a webpage, use the dedicated URL summarization endpoint instead of pasting raw HTML.
How do I retrieve the generated TL;DR?
Set a webhook to be notified as soon as it's ready, or fetch it from the signed result link, valid for 24 hours after completion.
What if generation fails?
It's retried automatically up to three times; if it still fails you receive a clear error and are never charged for that task.
Can I generate TL;DRs in bulk for many articles?
Yes, each call is an independent async task, so you can submit a batch and collect each one-liner as its webhook arrives.
How is this different from the bullet-point summary?
Bullet points return several discrete items; TL;DR returns exactly one sentence, so pick TL;DR when space is truly at a premium.
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/tldr \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/tldr", {
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/tldr",
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/tldr", 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/tldr", 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.tldr",
"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. |