Show notes
Show notes are the last chore standing between a finished recording and a published episode, and they're the part most hosts rush. This endpoint listens to the full episode and writes a summary, key points and highlighted quotes ready to paste into your podcast description or blog.
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 bottleneck this replaces
Writing show notes well means re-listening to an hour of audio, deciding what actually matters, and phrasing it so a stranger scanning a podcast app decides to press play. Most independent hosts either skip this step entirely, publishing a bare episode title, or outsource it and wait days for a draft back. Neither option fits a weekly release schedule, which is the problem this endpoint is built to solve.
What the output looks like
Call POST /audio/show-notes with the episode audio, and the task returns a structured write-up: a short episode summary, a list of key discussion points in order, and a handful of pullable quotes worth highlighting. Because it runs asynchronously, you send the file and move on — the finished notes land at your webhook, or wait at a signed link for 24 hours if you'd rather fetch them.
A format shaped by how podcasts get discovered
Podcast directories and search engines index episode descriptions as plain text, which is why show notes evolved into a predictable shape: a hook, a few bullet points, sometimes a pull quote near the top. That convention exists because it works for skimming, and it's the shape this endpoint targets rather than a loose paragraph that buries the useful information.
Who this saves the most time for
Solo hosts who record, edit and publish without a team feel this the most, since show notes are usually the task squeezed out when time runs short. Networks running multiple shows use it to keep notes consistent in tone and length across hosts who write very differently by hand, and agencies producing branded podcasts for clients use it to hit a delivery deadline without adding a dedicated copywriter to every episode.
Building it into a release workflow
This pairs naturally with the Podcast Chapters API, which supplies timestamps for the same episode — together they give you notes and navigation from a single audio file, ready to publish the moment editing wraps rather than a day or two after. Because both tasks accept the same audio input, a single upload can trigger both calls in parallel, so the finished episode page assembles itself from two asynchronous results instead of two separate manual steps.
What you can do with it
Weekly solo podcasts
Generate the description the moment an episode is exported, so publishing no longer waits on someone finding time to write notes by hand.
Interview shows
Turn a long-form conversation into a scannable summary and quote list that gives potential listeners a reason to click play.
Podcast networks
Standardize show notes across multiple hosts and shows without asking every host to write in the same style manually.
Archive migration
Backfill notes for older episodes that were published with only a title, improving how they perform in podcast search.
FAQ
What exactly do I get from the show notes generator API?
A summary, an ordered list of key points, and highlighted quotes from the episode, structured so they can be pasted directly into a podcast description or blog post.
Do I need to submit a transcript separately?
No, you send the audio and the transcript step happens internally as part of the task, so there's nothing to prepare beforehand.
Is this 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.
How is pricing calculated?
A base fee per request plus a rate per minute of audio, both published on this page, with no charge at all for a task that fails after retries.
How long does an episode take to process?
Processing time scales with audio length since the task is asynchronous; you're notified by webhook the moment the notes are ready rather than waiting on an open connection.
Can I use this for episodes in languages other than English?
The endpoint works across the same range of spoken languages supported elsewhere in the audio suite, so multilingual shows are supported without a separate configuration.
Will the notes need editing before I publish?
Treat the output as a strong first draft rather than a final copy — most hosts do a light pass for tone before publishing, since the structure and substance are already there.
Is my episode audio stored afterward?
No, audio is deleted after the retention window and is never used for training, so nothing from your episode persists beyond generating the notes.
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/show-notes \
-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/show-notes", {
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/show-notes",
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/show-notes", 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/show-notes", 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.show_notes",
"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. |