Text to bullets
A paragraph that makes five points becomes five bullets, not three: every fact, step and claim gets its own line, and only linking phrases such as «as a result» are trimmed. Format, not shortening. 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.
Dense paragraphs are where readers give up first.
Why dense paragraphs lose readers
Dense paragraphs are where readers give up first. A long block of prose asks the reader to hold several ideas in their head at once and untangle which clause modifies which before any single point lands. Bullet points remove that tax by giving each idea its own line, which is why product changelogs, executive summaries and onboarding documents lean on them so heavily. Restructuring text into bullets by hand, though, is mechanical work that eats editing time better spent on judgement calls, and that is the part handed over here.
Reformatting is not summarizing
The rewrite keeps every substantive point and strips only the connective filler. Engineering write-ups describing a set of fixes become a scannable changelog entry for end users. The narrative findings of a report become the bullets of a one-page summary that busy stakeholders will actually read. Dense policy or compliance paragraphs become separate lines, so each requirement is individually visible and easy to audit. A written explanation of a process becomes a step-by-step list new hires can follow without rereading. Teams use it as a first pass before human editing, often as soon as a draft is marked final.
Where this earns its place in a workflow
Teams turning long-form drafts into slide decks, release notes, or onboarding checklists use this as a first pass before human editing, since restructuring text into bullets by hand is mechanical work that eats editing time better spent on judgment calls. Running it asynchronously means a long document can be queued for reformatting the moment a draft is marked final, with the bulleted version ready before anyone opens the layout tool.
What you can do with it
Release notes from engineering write-ups
Convert a dense paragraph describing a set of fixes and changes into a scannable bulleted changelog entry for end users.
Executive summary prep
Turn a report's narrative findings section into bullet points for the one-page summary that busy stakeholders will actually read.
Policy and compliance documents
Reformat dense regulatory or internal-policy paragraphs into bullets so each requirement is individually visible and auditable.
Onboarding and how-to docs
Convert a written explanation of a process into a step-by-step bulleted list new hires can follow without rereading a paragraph twice.
FAQ
Will it create nested bullets if the text has sub-points?
Yes, when a paragraph has a clear main point with supporting details, the output reflects that with nested bullets rather than flattening everything to one level.
What input length works best?
It handles anything from a single dense paragraph to a full multi-page document; longer input is billed per word but processed the same way regardless of length.
Is there a free tier to test text to bullet point conversion?
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.
How much does converting text to bullets cost?
A failed task is never billed; three automatic retries happen first before a clear error is returned.
Does it leave anything out, the way a summary does?
No. A summary decides what to drop, while this decides how to lay out everything that is there. Each distinct claim, step or fact keeps its own bullet; only connecting phrases like «in addition to this» are removed.
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/to-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/to-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/to-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/to-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/to-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.to_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 endpoint takes prose — a report, a long email, a policy document — and rewrites it as a bulleted list that keeps every substantive point but strips the connective filler, so a reader can scan in seconds what used to take a full read-through.
Why paragraphs lose readers before bullets do
A dense paragraph asks a reader to hold several ideas in their head at once, untangling which clause modifies which, before any single point lands. Bullet points remove that tax by giving each idea its own line, which is why product changelogs, executive summaries, and onboarding docs lean on them so heavily. text.to_bullets automates that rewrite, taking a paragraph's worth of connected reasoning and breaking it into discrete, standalone points without losing what each one actually said.
What the rewrite actually preserves
POST /text/to-bullets identifies each distinct claim, step, or fact in the source paragraph and gives it its own bullet, trimming transitional phrases like 'in addition to this' or 'as a result' that exist to connect sentences rather than carry information. It does not compress or summarize away detail — a five-point paragraph becomes five bullets, not three, because the goal is format, not shortening.
The line between bulleting and summarizing
These are different tasks and this endpoint stays firmly on the bulleting side of that line: a summary decides what to leave out, while a bulleted rewrite decides how to lay out everything that's there. That distinction matters for anyone using the output for something like a compliance document or a technical spec, where dropping a clause silently would be a real problem rather than a stylistic simplification.
Nested structure when the source has it
Paragraphs often contain an implicit hierarchy — a main point followed by two supporting details — and the endpoint reflects that with nested bullets rather than flattening everything to one level, because a flat list of quite different orders of importance is often harder to scan than the paragraph it replaced.
Technical questions
Does the text to bullet points API shorten the content or just reformat it?
It reformats without cutting substance — every distinct point in the source paragraph gets its own bullet, and the task deliberately avoids summarizing detail away.
Can I bulk-convert many documents at once?
Yes, the endpoint is built for bulk use — queue as many asynchronous requests as needed and collect each result by webhook as it finishes.
How is the bulleted output delivered?
Through a signed webhook, recommended for automated workflows, or a signed link that remains valid for 24 hours for manual retrieval.
How is this different from a summarization endpoint?
Summarizing decides what to leave out; this endpoint restructures everything present in the source into bullets without discarding substantive content.