Summarize a text
Paste in a report, transcript or article and get back the substance, not the padding. 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.
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.
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. This endpoint exists for the moment you have a queue of documents and a deadline, not a free afternoon. 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.
How the request works
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. Either way, nothing sits in a queue waiting for you to poll it.
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. 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
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. 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.
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
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.
Is there a free tier?
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 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.
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/summarize \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Pegue aquí el texto largo que quiere resumir…"}'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": "Pegue aquí el texto largo que quiere resumir…"
})
});
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": "Pegue aquí el texto largo que quiere resumir…"
},
)
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":"Pegue aquí el texto largo que quiere resumir…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Pegue aquí el texto largo que quiere resumir…"}`)
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": "Pegue aquí el texto largo que quiere resumir…"
}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. |