Social thread
An article has one argument running start to finish; a thread has to work as a sequence of standalone posts that each earn a tap to the next one. This endpoint breaks a long piece into that sequence without leaving the middle posts feeling like filler.
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.
Why articles don't just chop into threads
The obvious approach — slice an article every few hundred characters — produces a thread where the third post makes no sense without the second, the fifth post has no hook of its own, and the whole thing reads like a document that got interrupted rather than a thread that was written to be read one post at a time. A real thread needs an opening that earns the first tap, a middle where each post can stand on its own for a second, and a close that doesn't just trail off. text.social_thread restructures rather than slices.
From a full article to a numbered sequence
POST /text/social-thread with your article or long-form text, get a task_id immediately, and the thread arrives by signed webhook or a signed link valid for 24 hours once processing finishes. The output is a numbered sequence of posts sized to fit platform limits, structured around the argument's actual turning points rather than its paragraph breaks, so the pacing of the thread doesn't just mirror the pacing of the source document.
The thread as its own format
The threaded format grew out of a real constraint — a single post was too short to carry a full argument — and turned that constraint into a structure with its own conventions: a strong opening line, one idea per post, and a close that resolves rather than just stops. Those conventions exist because a reader can drop off after any single post, so a thread that front-loads all its value into the first line and coasts after that loses most of its readers before the payoff arrives.
Where it fits in a content pipeline
Writers and content teams typically run this step right after publishing a long article or newsletter, repurposing the same reporting or argument into a second format instead of writing the thread from scratch. It also suits anyone converting a talk transcript, a long research writeup, or an internal memo into something meant to be read in a feed rather than a document viewer. Priced per request plus per thread, cost is predictable per piece repurposed, and a failed task is never charged.
What you can do with it
Repurposing a newsletter into a thread
A writer turns each week's long-form newsletter into a companion thread to reach readers who scroll a feed rather than open email.
Extending the life of a research writeup
A research team converts a detailed report into a thread that carries the key findings to an audience that won't read the full document.
Turning a conference talk into social content
A speaker converts their talk transcript into a thread that recaps the argument for people who missed the session.
Announcing a product deep-dive in digestible pieces
A product team turns a detailed release writeup into a thread that walks through the change post by post instead of one dense paragraph.
FAQ
How do I turn an article into a thread with the API?
POST the article text to /text/social-thread, keep the returned task_id, and collect the numbered thread by webhook or a signed link valid for 24 hours.
Is the thread generator API free?
No, there's no free tier or trial; it costs $0.003 per request plus $0.0135 per thread, and a failed task is never charged.
How is this different from just splitting text into character-limit chunks?
The output is restructured around the argument's turning points, with each post able to stand on its own, rather than mechanically sliced every few hundred characters.
How long can the source article be?
Long-form articles, reports and transcripts are the intended input; check the endpoint reference for the current maximum input length.
Can I control how many posts the thread has?
The length follows the source material's natural structure; very short inputs produce short threads and long ones produce longer sequences.
Can I generate threads for a backlog of past articles?
Yes, each article is its own async request, so a backlog is simply a batch of requests submitted together.
Is this endpoint live yet?
Yes, it's live and accepting requests now.
Is my article text kept after the thread is generated?
No, submitted text and generated threads are deleted after the retention window and are 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/social-thread \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/social-thread", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"input": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/social-thread",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"input": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/social-thread", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"input":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/social-thread", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"input": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.social_thread",
"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. |