Summarize in bullet points
A long customer review comes back as three or four points a product team can act on without reading the whole thing. Each item stands on its own, so the list is scanned top to bottom in seconds. 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.
Some text doesn't want to become a paragraph — it wants to become a list.
Why a list reads faster than a paragraph
A prose summary reads well, but it hides its structure: you have to get to the end to know whether there is a fourth point at all. A bulleted list puts that structure up front. Every item stands alone, the eye moves from top to bottom in seconds, and the list drops straight into a changelog, a slide or an email digest. Breaking ideas into separate points is far older than the typographic bullet, too: numbered commandments, itemized ship manifests and enumerated legal clauses all follow the same pattern. The bullet symbol simply made it visible.
Four everyday jobs for a bullet summary
Release notes: a raw dump of changes becomes a tidy list of what actually changed, ready to publish. Customer feedback: a long review turns into three or four points that a support or product team can act on. Meetings: the decisions and action items come out of the transcript as a short list rather than a narrative recap. Articles and newsletters: the key takeaways box at the top of a long piece can be filled automatically. In every case the hard part is not the symbol but the judgement of which sentences deserve a line of their own.
For when a paragraph is the wrong shape
A prose summary reads well but hides its structure — you have to read the whole thing to know if point four exists. A bulleted list front-loads that structure: each item stands alone, can be scanned top to bottom in seconds, and is trivial to render in a UI, a changelog, or an email digest.
A format older than bullet points themselves
Outlining ideas as discrete points predates the typographic bullet by a long way — think of numbered commandments, itemized ship manifests, enumerated legal clauses. The bullet symbol just made the pattern visual.
What you can do with it
Release notes generation
Turn a raw commit or changelog dump into a clean bulleted list of what actually changed, ready to publish.
Product review digesting
Convert a long customer review into three or four bulleted points a support or product team can act on without reading the whole thing.
Meeting takeaways
Extract the decisions and action items from a meeting transcript as a short list instead of a narrative recap.
Article key-points box
Auto-generate the 'key takeaways' bullets shown at the top of a long-form article or newsletter section.
FAQ
What if the task fails?
It's retried automatically up to three times; if it still fails you receive a clear error and are not charged for that attempt.
When is a bullet list better than a prose summary?
When the reader wants to know what the points are rather than enjoy the sentences. A paragraph hides its structure, so you must read all of it to learn whether a fourth point exists; a list shows every point at a glance.
Can it pull the decisions out of a meeting transcript?
Yes. Give it the transcript and you get the decisions and action items as a short list, instead of a narrative recap that someone still has to read from start to finish.
Can I turn a raw list of changes into release notes?
Yes. Paste the raw change log and it comes back as a clean bulleted list of what actually changed, ready to publish in release notes or an email digest.
How does it decide what becomes a bullet point?
It weighs which sentences deserve to stand as a point of their own and which are only connective tissue around them. The aim is a set of clean points that do not overlap, each carrying one idea.
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-bullets \
-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-bullets", {
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-bullets",
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-bullets", 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-bullets", 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_bullets",
"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 bullet point summary API takes long input and returns the key points as discrete, scannable items, the format people actually read when they're triaging fifty things at once instead of savoring one.
For when a paragraph is the wrong shape
This endpoint exists for release notes, meeting takeaways, product reviews and any input where the reader wants to know 'what are the points' faster than they want elegant sentences.
The mechanics of the call
Send your source text with a POST to /text/summarize-bullets. The call returns a task_id right away and the extraction runs in the background, because pulling clean, non-overlapping points out of dense text takes real processing time that shouldn't block your request thread. Delivery is via your signed webhook the moment it's done, or a signed link good for 24 hours if you'd rather fetch it yourself.
A format older than bullet points themselves
What this endpoint automates isn't the symbol, it's the harder cognitive step: deciding which sentences in a wall of text deserve to stand as their own point and which are just connective tissue around them.
Where it plugs in
Teams typically call this from a content pipeline that needs a 'key takeaways' box under an article, a changelog generator turning a raw commit log into readable release notes, or a customer-feedback tool converting a long review into three or four labeled points a product manager can act on directly. Because the response is asynchronous, it composes cleanly with a queue — fire off a batch, let each webhook land as it completes, and never hold a connection open waiting.
Pricing without surprises
Every task gets up to three automatic retries before it's marked failed, and a failed task is never billed — the only charges you'll see correspond to bullet lists that were actually delivered to you. You pay a small flat fee per request plus a rate per 1,000 words of input, published up front.
Technical questions
How many bullet points does the API return?
The count adapts to how much distinct information is in your text — dense input yields more points, short input yields fewer, rather than forcing a fixed count.
Is the bullet point summary API free to use?
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 input format does it accept?
Plain text in the request body. Strip HTML or PDF content down to text first, or use the URL summarization endpoint if your source is a web page.
Can I control how many bullets come back?
The endpoint optimizes for coverage of distinct points rather than a fixed count; for very short output, pair it with the TL;DR endpoint instead.
How do I retrieve the result?
Set a webhook to get notified the moment the list is ready, or fetch it from the signed result link, valid for 24 hours after the task completes.
Can I process many documents at once?
Yes, each call is an independent async task, so you can submit a batch in parallel and collect each bulleted summary as its webhook fires.
How is this different from the plain text summarizer?
The plain summarizer returns flowing prose; this endpoint returns discrete, scannable points — use whichever matches how the result will be read.