Podcast chapters
A ninety-minute conversation is only as useful as its map. This endpoint listens to the episode, finds where the topic actually shifts, and hands back a clean list of timestamped chapters with titles — the same structure listeners expect on any modern podcast player.
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 chapters matter more than a full transcript
Most listeners never read a transcript, but nearly all of them glance at chapter markers to decide whether to skip ahead or go back. Editors have known this for years and used to write chapters by hand, scrubbing through a waveform and guessing where one segment ends and the next begins. That manual pass is slow, subjective, and the first thing cut when a release schedule gets tight — which is exactly the gap this API closes.
What happens after you send the file
You POST a link to the audio (or the file itself) to /audio/chapters, and the task runs asynchronously: the audio is transcribed internally, topic boundaries are detected from shifts in vocabulary and pacing, and each segment is given a short, human-readable title along with its start time in seconds. There is no polling required — you either supply a webhook URL to receive the finished chapter list, or fetch it from a signed link that stays valid for 24 hours.
Where chapter markers came from
Timestamped chapters trace back to CD track lists and DVD scene selection, long before podcasting existed; RSS feeds later adopted the same idea through the Podcast Namespace's chapters tag, letting apps like Apple Podcasts and Overcast render clickable segments. This endpoint outputs chapter data in a form that maps directly onto that convention, so you are not inventing a new format — you are automating one podcasters already trust.
Who reaches for this endpoint
Independent podcasters publishing weekly with no editorial staff, networks producing dozens of shows where manual chaptering does not scale, and platforms that let creators upload raw audio and expect structured output back all use this task the same way: as one call in a larger publishing pipeline.
Fitting it into your pipeline
Because the response is plain, structured data — titles and second-level timestamps — it drops straight into an RSS chapters tag, a video description, or a database column without reformatting. Chain it after a raw upload and before the Show Notes API for a fully automated release: audio in, chapters and notes out.
What you can do with it
Weekly podcast automation
Pipe each new episode straight from your recording tool into this endpoint the moment it's exported, so chapters are ready before the editor even opens the file.
Back-catalog cleanup
Run hundreds of older episodes through the API in a batch to retrofit chapter markers your show never had, improving navigation for long-time listeners.
Podcast hosting platforms
Offer chapter generation as a built-in feature for creators who upload raw audio, without maintaining your own audio-analysis stack.
Video-to-podcast repurposing
Generate chapters from the audio track of a recorded livestream or webinar before publishing the video version, keeping both formats consistent.
FAQ
Does the auto chapter generator API work on any audio length?
Yes, long episodes are handled without a separate upload step; price scales with the audio's duration in minutes, so cost is predictable regardless of length.
What format are the chapters returned in?
You get a structured list of titles with start times in seconds, which maps directly onto the Podcast Namespace chapters convention used by most podcast apps.
Is there a free tier to test it?
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 request billed?
A small per-request base fee plus a per-minute rate on the audio's length, both published on this page. A task that fails after retries is never charged.
How do I get the result back?
Either a signed webhook call when the task completes, or a signed link valid for 24 hours if you'd rather poll. Choose whichever fits your infrastructure.
Can I edit the chapter titles afterward?
The response is plain JSON, so titles and timestamps can be adjusted before you publish — the API gives you a strong first draft, not a locked-in final.
Does it work for interviews with multiple speakers?
Yes, chapter boundaries are based on topic and pacing shifts rather than speaker identity, so multi-guest formats are supported without extra configuration.
Is my audio kept after processing?
No. Files are deleted after the retention window and are never used to train models — the audio only exists long enough to produce your chapters.
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/chapters \
-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/chapters", {
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/chapters",
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/chapters", 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/chapters", 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.chapters",
"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. |