Content outline
A blank page is expensive. The Content Outline API takes a topic, a rough draft, or a set of source notes and returns a structured skeleton — headings, subpoints, and suggested flow — so a writer or a content pipeline can start from architecture instead of guesswork. It exists for the moment right before writing, when the real bottleneck is deciding what goes where.
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.
Who actually needs a machine-made outline
Editorial teams publishing on a schedule, agencies producing briefs for freelance writers, and product teams generating documentation all hit the same wall: someone has to decide the shape of a piece before anyone writes a sentence. That decision is repetitive and rule-based enough to automate, but subtle enough that a naive summary won't do. This endpoint is built for that exact gap — not to write the article, but to make the architecture decision so a human or a downstream model can execute faster.
What you send and what comes back
You POST a topic or a body of source text to /text/outline along with optional parameters for depth and target length. The task runs asynchronously: you get a task_id immediately, and the finished outline — a nested list of headings and short descriptors of what each section should cover — arrives at your webhook or a signed link within the processing window. There is no synchronous call to wait on, which matters when you are outlining hundreds of pieces in a content calendar at once.
Why outlines resist a simple template
Outlining looks mechanical from the outside, but a good one balances two competing needs: logical progression (each section should set up the next) and reader intent (someone scanning headings should immediately understand the piece's value). Journalists have used the inverted pyramid for a century for exactly this reason — lead with what matters, support with detail. The outline task is tuned to respect that kind of structural logic rather than just chopping a topic into evenly spaced subheadings.
Fitting it into a pipeline
Because the endpoint is async and billed per call, it slots cleanly into a larger automation: a content calendar tool calls /text/outline for every planned title, stores the returned structure, and later feeds each outline to a drafting step or hands it to a human writer as a brief. Nothing is charged unless the task actually completes — a failed attempt is retried automatically and never billed, so batch jobs stay predictable in cost.
What quality to expect
The output favors clarity over cleverness: descriptive headings, a sensible number of sections for the requested length, and short notes on intent per section rather than padded prose. It is a scaffold, not a finished piece — the value is in saving the structural decision-making time, leaving the actual writing, voice, and fact-checking to you or your next pipeline step.
What you can do with it
Editorial calendars at scale
A publisher queues fifty planned headlines overnight and wakes up to fifty structured briefs ready to hand to freelancers.
Documentation from feature specs
A product team turns an internal spec into a draft doc outline before a technical writer touches it, cutting the blank-page phase entirely.
Repurposing long-form into sections
An agency feeds a 3,000-word report into the endpoint to get a clean section map before slicing it into a newsletter series.
SEO brief generation
A content ops tool combines a target keyword with a short brief and returns an outline writers can follow without a strategist's manual review.
FAQ
How do I call the content outline generator API?
Send a POST request to /text/outline with your topic or source text; the task runs asynchronously and the outline arrives by webhook or a signed link.
Is there a free tier for this content outline generator API?
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.
How is the outline task priced?
$0.003 per request plus $0.0135 per 1,000 words of source text processed, billed only on successful completion.
What input formats are accepted?
Plain text is accepted for both the topic and any source material; there's no need to pre-format it into a specific markup.
How long can the source text be?
You can submit anything from a short topic phrase to a long draft or report; pricing scales with word count, so larger inputs simply cost proportionally more.
What happens if the outline task fails?
Failed tasks are retried automatically up to three times and are never charged if they don't complete successfully.
Can I control how detailed the outline is?
Yes, you can pass parameters for target depth and length so the returned structure matches a short post or a long-form piece.
How do results get delivered?
Via a signed webhook call, which we recommend for automation, or a signed link valid for 24 hours; source data is deleted after the retention window and never used for training.
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/outline \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/outline", {
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/outline",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/outline", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/outline", 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.outline",
"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. |