ForHosting KIT · Audio & Voice

Clean up a transcript

Raw transcripts are full of 'um', repeated words, dangling clauses and missing commas — readable to the person who spoke them, exhausting for anyone else. This clean transcript API takes that raw text and returns a punctuated, filler-free version ready to publish, summarize or feed into another model.

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

The gap between speech and text

Speech-to-text engines are graded on word accuracy, not readability, so their output faithfully captures every 'uh', restart and run-on sentence a speaker produces. That fidelity is correct for a court record but wrong for a blog post, a help-center article or a podcast show note. This endpoint sits after your transcription step and closes that gap: it removes disfluencies, merges fragments into proper sentences, and inserts punctuation and capitalization so the text reads the way the speaker meant it, not the way they said it.

What the request expects and returns

Send the raw transcript text as plain text in the request body; there is no audio involved at this stage, only the words a transcription step already produced. The task runs asynchronously: you get a task_id immediately, and the cleaned transcript arrives later as a signed webhook payload or a signed link valid for 24 hours. The output preserves meaning and speaker intent — it edits for clarity, it does not summarize or paraphrase content away.

Who reaches for this

Podcast producers turning episodes into show notes, support teams converting recorded calls into searchable knowledge-base articles, and researchers cleaning interviews before qualitative coding all hit the same wall: manual cleanup takes longer than the recording itself. Feeding transcripts through this endpoint before a human editor touches them cuts that manual pass down to a final read-through.

Where it fits in a pipeline

Because it is a discrete, stateless step, it slots naturally between a speech-to-text call and whatever comes next — a summarizer, a translation task, or a CMS import. Pricing is a small per-request base fee plus a per-1000-word rate, so cost scales with transcript length, and a failed task is never billed; the system retries automatically before returning a clear error.

Access and delivery

Like every endpoint in the API, this one requires prepaid balance — no free tier, no trial, which keeps usage abuse-free and the queue fast for paying workloads. Cleaned transcripts are deleted after the retention window and are never used to train models; you get your text back through your webhook or a temporary signed link, nothing more.

What you can do with it

Podcast show notes

Turn a raw auto-transcript of a 45-minute episode into clean paragraphs a producer can paste straight into the episode description.

Support call knowledge base

Clean up recorded support-call transcripts in bulk so they can be indexed and searched without the 'um, so, like' noise burying the answer.

Interview transcription for research

Prepare interview transcripts for qualitative coding by removing false starts while keeping every substantive word the participant said.

Pre-processing for a summarizer

Clean a transcript before passing it to a summarization task so the summary is built from clear sentences, not fragmented speech.

FAQ

What does the clean transcript API actually remove?

It strips filler words like 'um' and 'uh', removes false starts and repeated words, and adds punctuation and capitalization, without changing the meaning of what was said.

Do I send audio or text to this endpoint?

You send the raw transcript text — audio has already been converted to text by a separate transcription step before this one runs.

Is there a free tier for the clean transcript 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 clean transcript API priced?

It costs $0.003 per request plus $0.0135 per 1000 words of transcript, so cost scales with text length.

How do I get the cleaned result back?

The task runs asynchronously and returns a task_id right away; the cleaned transcript is delivered via a signed webhook or a signed link valid for 24 hours.

Will it summarize or shorten my transcript?

No. It edits for readability only — punctuation, filler removal, sentence structure — it does not summarize or cut content.

What happens if a cleanup task fails?

Failed tasks are retried automatically up to three times and are never charged; if all retries fail you receive a clear error instead of a bill.

Can I clean transcripts in bulk?

Yes, submit one request per transcript; each is queued and processed asynchronously, so you can send many in parallel and collect results as they complete.

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/audio/clean-transcript

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

const res = await fetch("https://api.kit.forhosting.com/audio/clean-transcript", {
  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/audio/clean-transcript",
    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/audio/clean-transcript", 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/audio/clean-transcript", 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": "audio.clean_transcript",
  "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_mb`	200
`max_minutes`	180

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 →