Fix punctuation
Speech-to-text engines and stream-of-consciousness input rarely arrive with a single comma. The Punctuation Restoration API reads unbroken text or raw transcripts and inserts periods, commas, question marks and capitalization where they belong, turning a wall of words into readable sentences.
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.
The gap transcription tools leave behind
Many transcription and speech-recognition systems output a continuous stream of lowercase words with no sentence boundaries at all, because punctuation carries almost no acoustic signal — a pause before 'but' sounds a lot like a pause before a period. That gap is exactly what this endpoint closes: it takes that raw stream and reconstructs sentence structure from language patterns rather than audio cues.
What happens after you send text
A request to POST /text/punctuation is queued as an async task; the model analyzes syntax, likely clause boundaries, and speech patterns like filler words or run-on lists to decide where a comma separates items, where a sentence should end, and where a question mark or capital letter belongs. The punctuated text comes back through your signed webhook or a signed link, ready to read or feed into the next step.
Why punctuation is harder than it looks
Written punctuation is a relatively recent invention — ancient texts were often written with no spaces or marks at all, and standardized comma and period usage only settled in the last few centuries as printing spread. Restoring it from raw text means inferring intent the original speaker never made explicit, so results reflect the most probable reading of ambiguous phrasing rather than a single guaranteed truth.
A natural step before other text tasks
Unpunctuated text breaks almost every downstream tool: readability scoring assumes sentence boundaries, summarizers lose structure, and proofreading tools flag phantom run-on errors. Placing punctuation restoration right after a transcription job and before anything else in your pipeline gives every later step text it can actually parse correctly.
Straightforward, usage-based pricing
Cost is $0.003 per request plus $0.0135 per 1,000 words processed, so a five-minute call transcript costs about the same whether it's one file or batched with a hundred others. Only successfully completed tasks are billed — failed jobs are retried up to three times automatically, and if they still can't complete you get a clear error with no charge. That predictability matters most at scale: a support team punctuating thousands of call transcripts a week can forecast the exact monthly cost from word volume alone, with no separate per-minute or per-file surcharge to account for.
What you can do with it
Post-call transcript cleanup
Feed raw output from a speech-to-text engine straight into the API before storing call recordings as searchable, readable support logs.
Voice-note to document pipeline
Turn dictated voice memos into properly punctuated drafts ready for a human editor to review, instead of a run-on paragraph.
Subtitle and caption preprocessing
Restore sentence structure to raw ASR output before splitting it into timed subtitle lines, so breaks land on natural sentence boundaries.
Legacy text normalization
Clean up old exports or scraped text that lost punctuation somewhere in a conversion pipeline, making it usable again for search and display.
FAQ
How does the punctuation restoration API work?
You send unpunctuated text to POST /text/punctuation, the async task analyzes sentence structure and speech patterns, and returns punctuated, capitalized text via webhook or signed link.
Is it free to try?
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.
Does it work on transcripts from any speech-to-text tool?
Yes — it works on any raw unpunctuated text regardless of source, whether it came from a transcription engine, dictation software, or manually stripped text.
Will it change my wording?
No, it only adds punctuation, capitalization, and sentence boundaries; it does not rewrite, summarize, or alter the actual words you send.
How is the price calculated?
Pricing is $0.003 per request plus $0.0135 per 1,000 words, billed only for tasks that complete successfully, published upfront with no hidden per-token charges.
Can I process large batches of transcripts overnight?
Yes, every call is asynchronous with webhook delivery, so you can queue large batches and let results arrive as each task finishes.
What happens if a punctuation task fails?
The system retries automatically up to three times; if it still fails you receive a clear error message and are never billed for that task.
Should I run this before or after other text tools?
Run it right after transcription and before readability scoring or proofreading, since those tools depend on correct sentence boundaries to work accurately.
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/punctuation \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/punctuation", {
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/punctuation",
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/punctuation", 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/punctuation", 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.punctuation",
"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. |