Home → Blog → Podcast transcription: show notes, chapters and searchable episodes

Podcast transcription: show notes, chapters and searchable episodes

Published 2026-08-05 · 6 min read

Audio is invisible to search engines. An hour-long episode packed with expert answers brings in exactly as much organic traffic as an empty page — until you publish the text. A transcript is also the cheapest source of show notes, chapters, quotes and social posts.

What a transcript gives a podcast

One transcription request feeds four different jobs:

Organic search. The episode page starts ranking for the questions your guest answered, not just for the show title.
Accessibility. Listeners with hearing loss, and everybody on a commute without headphones, can read instead.
Repurposing. Quotes for social media, a newsletter summary and a blog post all come out of the same text.
Navigation. Chapters with timings let people jump straight to the part they came for.

Preparing the audio file

Send the released episode — the mixed and mastered file — rather than raw tracks. If it does not fit the 25 MB request limit, re-encode it for recognition only:

ffmpeg -i episode-42.wav -ac 1 -ar 16000 -b:a 48k episode-42.mp3

This copy is used for transcription only, so quality loss does not matter — mono at 16 kHz is what the model works with internally anyway.

Getting the transcript with timings

Ask for verbose_json: it returns both the full text and segments with start and end times, and chapters are built from those segments.

from openai import OpenAI

client = OpenAI(base_url="https://voicesscribe.com/v1", api_key="your key")

with open("episode-42.mp3", "rb") as f:
    r = client.audio.transcriptions.create(
        model="whisper-1", file=f,
        response_format="verbose_json",
        prompt="Guest: Maria Alvarez, CTO at Nordwind Systems. Topics: observability, OpenTelemetry, on-call rotation.",
    )

open("episode-42.txt", "w", encoding="utf-8").write(r.text)

Put the guest name, the company and the main terms into prompt. Names are the first thing a general model gets wrong, and they are exactly what people search for.

Building chapters from segments

Chapter markers are just timestamps with titles. Group the segments into blocks of a few minutes, then let a language model name each block:

blocks, cur, start = [], [], 0
for s in r.segments:
    cur.append(s.text)
    if s.end - start > 300:            # roughly five-minute blocks
        blocks.append((start, " ".join(cur)))
        cur, start = [], s.end
blocks.append((start, " ".join(cur)))

for t, text in blocks:
    print(f"{int(t)//60:02d}:{int(t)%60:02d}  {title_for(text)}")

The result goes straight into the episode description on the platforms that support chapter timestamps, and into the page on your own site.

Writing show notes from the transcript

Show notes are a summary plus links plus quotes. All three can be drafted from the text in one pass:

notes = llm(f"""From this podcast transcript produce:
- a two-sentence episode summary,
- five bullet points of what the guest actually claims,
- three quotable lines, verbatim,
- every book, tool and company mentioned.

{transcript}""")

Always check the list of names and products by hand. A transcript is accurate on ordinary speech and least reliable exactly where proper nouns appear — which is where a factual error is most visible.

Publishing so that search engines read it

The transcript only works for search if it is on the page as text:

Plain HTML, not a PDF or an image. Put the text in the page body, ideally with timestamps as subheadings.
One page per episode with its own title and description, not one long archive page.
A VTT track next to the player so listeners can follow along: response_format="vtt" returns it ready to use.
Structured data. Mark the page up as a PodcastEpisode so the episode is shown as a media object rather than an article.

Do not paste raw recognition output. Ten minutes of splitting into paragraphs and fixing names is the difference between a page people read and a wall of text they leave.

How much this costs to run

Billing is per minute of audio, so the arithmetic is predictable: a weekly show with one-hour episodes is about four hours of transcription a month. That is the cheap part of a podcast — cheaper than hosting, and far cheaper than the editing that produced the episode.

Processing is faster than real time, so a full back catalogue can be transcribed in one batch run overnight and published as an archive of searchable pages.

Try it on your own recordings. Sign-up takes a minute, and the free minutes are enough to judge the quality.

Get a free API key

Frequently asked questions

Should I publish the full transcript or just a summary?

Publish the full text: that is what makes the episode findable for the long-tail questions your guest answered. A summary at the top helps readers decide whether to keep going.

Will the transcript get the guest's name right?

Pass the guest name and company through the prompt parameter and it usually will. Proper nouns are the weak spot of any recognition model, so check them before publishing.

How do I get chapters with timestamps?

Request verbose_json: it returns segments with start and end times. Group those segments into blocks of a few minutes and title each block.

Can I transcribe an episode with two hosts and a guest?

Yes, the speech is transcribed in full, but a single mixed file does not come back labelled by speaker. If the raw multitrack session is still available, transcribe the tracks separately.

What about episodes in more than one language?

The language is detected from the start of the recording, so a bilingual episode is best split into fragments and transcribed one language at a time.