Show notes
Upload the episode audio and get back a short summary, the key discussion points in order and a handful of quotes to highlight, ready for your podcast description or blog. No more re-listening to an hour of audio. Pay per use, no subscription.
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.
Show notes are the last chore standing between a finished recording and a published episode, and they're the part most hosts rush.
Why show notes get rushed
Show notes are the last chore between a finished recording and a published episode, and they are the part most hosts rush. Doing them well means re-listening to an hour of audio, deciding what matters and phrasing it so a stranger scanning a podcast app decides to press play. Solo hosts often skip the step and publish a bare title, or hand it to someone else and wait days for a draft. This tool listens to the full episode and returns a short summary, the key discussion points in the order they come up, and a handful of quotes worth highlighting.
The shape that works for skimming
Podcast directories and search engines read episode descriptions as plain text, which is why good notes settled into a predictable shape: a hook, a few bullet points and sometimes a pull quote near the top. That is the shape you get back, not a loose paragraph that buries the useful parts. Networks use it to keep notes consistent across hosts who write very differently, agencies use it to meet client deadlines, and archives use it to backfill older episodes that went out with only a title. Read the draft before publishing and adjust names or emphasis to your voice.
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.
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.
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
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. No subscription, no tokens, no invented credits, and a failed task is never charged.
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.
What do the generated show notes include?
A short episode summary, a list of the key discussion points in the order they come up and a handful of quotes worth highlighting. It follows the hook, bullets and pull quote shape that podcast listeners skim.
Related tools
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, by email and from Telegram — and soon from our app too.
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. |
Technical notes
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.
The bottleneck this replaces
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.
Building it into a release workflow
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. 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.
Technical questions
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.
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.