Summarize audio
You don't have an hour to listen back to a call, a lecture, or a webinar you half-attended, and neither does anyone you'd forward it to. This endpoint listens for you and hands back the part worth knowing.
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 a recording and a decision
A raw recording is not information, it's a container for information, and someone still has to sit through it to extract anything usable. That cost scales badly: a company recording ten hours of calls a day is generating ten hours of listening someone has to do, or more realistically, is not doing. audio.summarize exists to close that gap without asking a person to spend the hour.
What the summary actually contains
POST /audio/summarize with your audio file, get a task_id back, and receive a written summary by webhook or a signed 24-hour link once it's ready. The summary follows the shape of what was actually said — the arc of a lecture, the back-and-forth of an interview, the recap of a briefing — rather than forcing every input into one rigid template, because a sales call and a university lecture do not compress the same way.
Why length still matters for summarization
Text summarization research has spent decades on the same core tension — compress without losing what matters — and audio summarization inherits that tension plus the added noise of speech itself: filler words, false starts, crosstalk. The model has to separate signal from the ordinary mess of how people actually talk before it can decide what belongs in a page.
What it is not trying to be
This is a summary, not a verbatim transcript and not a legal record — if you need the exact wording, pair it with a transcription task instead, or alongside it. Treat the output as a fast, honest read of what a recording contains, useful for deciding whether the full thing is worth anyone's time.
Where it earns its keep in a pipeline
Podcast producers use it to generate episode descriptions without re-listening to their own show. Customer success teams summarize onboarding calls into a paragraph that goes straight into the CRM. Because it runs async and bills per request plus per minute, it scales cleanly whether you're summarizing one webinar or a week's backlog of recorded interviews.
What you can do with it
Webinar recap for no-shows
A marketing team emails registrants who missed a live webinar a written summary instead of asking them to watch a 60-minute recording.
Lecture review before exams
A university course posts written summaries of recorded lectures so students can review key points without replaying every session.
Podcast show notes
An independent podcast generates its episode description and highlights directly from the raw recording instead of manual note-taking.
Long-form interview screening
A researcher summarizes hours of recorded interviews to decide which ones warrant full transcription and analysis.
FAQ
How do I summarize an audio file with the API?
Send it to POST /audio/summarize, store the returned task_id, and get the written summary by webhook or a signed link valid for 24 hours.
Is the audio summarizer API free?
No, there is no free tier or trial. It costs $0.004 per request plus $0.0185 per minute of audio, and failed tasks are never charged.
How long can the source audio be?
It's designed for long recordings — calls, lectures, webinars — since it runs asynchronously and is billed per minute rather than capped at a fixed short length.
Does the summary include speaker names?
It reflects who said what when that's discernible from the audio, but for guaranteed per-speaker labeling pair it with a diarized transcription task.
Can I control how long the summary is?
The summary is scaled to match the source's length and structure by default; check the endpoint reference for available length parameters.
How is this different from a transcript?
A transcript is the full spoken text; a summary is a compressed, written account of what mattered, meant to be read in a fraction of the listening time.
Can I bulk-summarize many files?
Yes, submit multiple async tasks and collect each result by webhook as it completes, which is how most integrations handle batches.
Is the audio kept after summarizing?
No, audio and results 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/audio/summarize \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"audio":"https://ejemplo.com/audio.mp3"}'const res = await fetch("https://api.kit.forhosting.com/audio/summarize", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"audio": "https://ejemplo.com/audio.mp3"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/audio/summarize",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"audio": "https://ejemplo.com/audio.mp3"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/audio/summarize", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"audio":"https://ejemplo.com/audio.mp3"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"audio":"https://ejemplo.com/audio.mp3"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/audio/summarize", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"audio": "https://ejemplo.com/audio.mp3"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "audio.summarize",
"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_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. |