ForHosting KIT · Text & AI

Summarize in bullet points

Some text doesn't want to become a paragraph — it wants to become a list. 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.

● StablePer request + per 1,000 words$0.003

Run — $0.003 + $0.0135/1,000 words How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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.

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. 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

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 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

You pay a small flat fee per request plus a rate per 1,000 words of input, published up front. 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.

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

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.

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.

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.

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

POSThttps://api.kit.forhosting.com/text/summarize-bullets

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-bullets \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"text":"…"}'

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": "…"
  })
});
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[&#39;KIT_KEY']}"},
    json={
    "text": "…"
},
)
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" => &#39;{"text":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"…"}`)
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": "…"
}

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

Per request$0.003

Per 1,000 words$0.0135

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.

Read the full KIT documentation →