Summarize a text
Nobody on your team has to skim a 4,000-word document again to find the three sentences that matter: paste it in and get back the substance without the padding, as long or as short as you need. You pay per use, with 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.
Paste in a report, transcript or article and get back the substance, not the padding.
What a good summary keeps and what it leaves out
Boiling a text down to its core claims is something librarians and editors have done for centuries: the executive précis, the newspaper lede and the academic abstract are the same instinct in different clothes. A good summary keeps the statements that carry the meaning and drops the repetition, the warm-up and the asides. That is the job here. You paste in raw text, choose the maximum length you want back, and receive a shorter version that still says what the original says, ready to read in seconds instead of minutes.
Where a summary saves the most time
Every organization produces more text than anyone can read closely. A support team can turn a long ticket thread into a two-line brief, so the agent sees the real issue before opening the whole conversation. A research team can condense a paper or a long report into one paragraph and decide in seconds whether the full document deserves their time. Editors can draw the short description under a headline or in a newsletter straight from the article body. And a meeting transcript can become a compact record kept next to the recording, so nobody has to replay an hour of audio to remember what was decided.
Built for the pile of text nobody has time to read
Support tickets, legal drafts, meeting transcripts, research papers, customer reviews — every business generates far more text than any human can read closely. Feed it raw text and get a summary sized to what you actually need, whether that's a paragraph for a dashboard or a few lines for a Slack notification.
Summarization is older than software
Abstracting a text down to its core claims is a skill librarians and editors have practiced for centuries — the executive precis, the newspaper lede, the academic abstract are all the same instinct in different clothes. What's new is doing it on demand, at the volume a modern application produces, without a human editor sitting between the source and the output.
What you can do with it
Support ticket triage
Summarize incoming ticket threads into a two-line brief so agents see the actual issue before opening the full conversation.
Research digesting
Condense academic papers or long reports into a paragraph that lets a team decide in seconds whether the full document is worth reading.
Content pipelines
Generate the short description shown under a headline or in a newsletter, pulled straight from the full article body.
Meeting archives
Turn raw transcripts into a compact summary stored alongside the recording, so nobody has to replay an hour of audio to recall what was decided.
FAQ
Is there a free tier?
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.
What kinds of text can I summarize?
Any plain text you paste in: reports, meeting transcripts, news articles, support ticket threads, legal drafts, research papers or batches of customer reviews. The summary keeps the core claims and leaves out the repetition and padding around them.
Can I choose how long the summary is?
Yes. You set the maximum number of words, so the same text can become a paragraph for a team dashboard or two short lines for a Slack notification.
Will the summary change the meaning of my text?
It should not: the aim is a shorter version that keeps the meaning, the way an editor writes an abstract or a newspaper lede. What gets dropped is the padding around the main points, not the points themselves.
How long is a finished summary available?
Long documents are processed in the background, so you are never left waiting on an open page. When the summary is ready, it can be collected from a secure link that stays valid for 24 hours.
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/text/summarize \
-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/text/summarize", {
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/text/summarize",
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/text/summarize", 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/text/summarize", 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": "text.summarize",
"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. |
Technical notes
This text summarization API reads what you give it and hands back a shorter version that keeps the meaning, so nobody on your team has to skim a 4,000-word document to find the three sentences that matter.
Built for the pile of text nobody has time to read
This endpoint exists for the moment you have a queue of documents and a deadline, not a free afternoon.
How the request works
Either way, nothing sits in a queue waiting for you to poll it. Send your text as a POST to /text/summarize and the call returns immediately with a task_id — the summarization itself runs asynchronously so you're never left holding an open connection while a long document processes. When it's done, the result lands in your signed webhook, or you can fetch it from a signed link that stays valid for 24 hours.
Summarization is older than software
That's the gap this endpoint fills.
Where it sits in a pipeline
Most callers don't summarize text as a standalone action — they summarize it on the way to something else: indexing documents for search, generating a preview snippet, feeding a shorter version into a downstream model with a tight context budget, or simply logging a compact record of what a long support thread was actually about. Because the endpoint is async and webhook-driven, it drops into an existing task queue or automation without your code ever blocking on it.
What you pay for and nothing else
If a summarization attempt fails outright, we retry it up to three times automatically and you are never billed for a failed task; you'll only ever see a charge next to a summary that actually reached you. Pricing is a small flat fee per request plus a per-word rate on the input, published and predictable — no bundled credits, no invented tiers.
Technical questions
How does the text summarization API decide what to keep?
It identifies the claims and details that carry the most meaning in your input and rewrites them into a shorter, coherent version rather than just deleting sentences.
What text formats can I send?
Send plain text in the request body. If your source is HTML, PDF or a webpage, strip it to text first, or use the dedicated URL summarization endpoint for links.
Is there a length limit?
Very long inputs are supported since pricing scales per 1,000 words, but extremely large payloads should be chunked for reliability and faster turnaround.
How do I get the result back?
Provide a webhook URL to be notified the moment the summary is ready, or poll the signed result link, which stays valid for 24 hours after completion.
What happens if the request fails?
Failed tasks are retried automatically up to three times; if it still fails you get a clear error and you are never charged for that task.
Can I run this on many documents in bulk?
Yes — each document is its own async task, so you can fire many requests in parallel and collect results as each webhook arrives.
How is this different from bullet-point or executive summaries?
This endpoint returns prose-style condensed text; if you need a scannable list or a decision-focused brief for leadership, those are separate dedicated endpoints.