Podcast Transcript Example and Format (SRT, VTT, JSON)

A transcript can be a wall of text in a document, a caption file that plays in sync with the audio, or a structured file that podcast apps read from your RSS feed. These are different formats with different jobs, and most guides show only the first.

This page shows the same four lines of an invented interview in each common format, explains which one to publish for which purpose, and gives a short script that turns one timestamped transcript into two of them. The technical details for the RSS tag come from the Podcast Namespace documentation, read on September 26, 2026. The guest, show and lines below are made up for this post.

What a good podcast transcript contains

Transcription style guides, such as those from GMR Transcription and PodMuse, tend to agree on the basics:

• Speaker labels. Use the person's name, or "Host" and "Guest" if you prefer, followed by a colon. Keep the same label for a speaker throughout.
• A new line for each speaker turn. Break long turns into shorter paragraphs so the page can be scanned.
• Timestamps. Either one every minute or two, or one at each speaker change. Every one to three minutes is a common range.
• Correct names and terms. A transcript that spells a guest three ways hurts search and looks careless. Our guide to fixing names and jargon covers a glossary method.

Decide early whether to keep filler words. A verbatim transcript keeps every "um" and false start. A clean transcript removes them and keeps the meaning. Most podcasts publish clean transcripts, because they read better and the audio is there for anyone who wants the exact delivery.

The same transcript in five formats

1. Plain text with speaker labels

The simplest format, and the one most people mean by "a transcript."

Maya: Welcome to Spoke and Sprocket. Today I'm talking with Dana Ortiz.
Dana: Thanks for having me.
Maya: Let's start with the second shop. Why did you close it?
Dana: It came down to rent and one bad winter.

Good for reading, searching and pasting into an AI tool. It carries no timing, so it cannot drive captions.

2. Text with timestamps

Adds a time to each turn, which lets a reader jump to a moment in the audio.

[00:00:00] Maya: Welcome to Spoke and Sprocket. Today I'm talking with Dana Ortiz.
[00:00:07] Dana: Thanks for having me.
[00:00:10] Maya: Let's start with the second shop. Why did you close it?
[00:01:42] Dana: It came down to rent and one bad winter.

This is the best working format. It is easy to edit by hand and easy to convert, and the script below starts from it.

3. SRT

SRT is a caption format, with numbered cues and start and end times. The Podcast Namespace's own examples call it a medium-fidelity option, with a two-line maximum and about 32 characters a line, and speaker names shown when the speaker changes.

1
00:00:00,000 --> 00:00:04,000
Maya: Welcome to Spoke and
Sprocket. I'm here with Dana.

2
00:00:07,000 --> 00:00:10,000
Dana: Thanks for having me.

The lines are shortened here to fit the 32-character guideline, which is why an SRT file usually splits one spoken turn across several cues.

Use SRT for video platforms that ask for a caption file. Note the comma before the milliseconds, which differs from WebVTT.

4. WebVTT

WebVTT is the web version of captions. It uses a period before the milliseconds and supports a voice tag, <v Name>, to mark who is speaking. The Podcast Namespace examples recommend it, suggesting a maximum line length of about 65 characters.

WEBVTT

00:00:00.000 --> 00:00:07.000
<v Maya>Welcome to Spoke and Sprocket. Today I'm talking with Dana Ortiz.

00:00:07.000 --> 00:00:10.000
<v Dana>Thanks for having me.

Use WebVTT for web players and for the RSS tag described below.

5. Podcasting 2.0 JSON

The Podcast Namespace defines a JSON transcript with a version, a list of segments, and for each segment a speaker, a startTime in seconds, an optional endTime and the body text.

{
  "version": "1.0.0",
  "segments": [
    { "speaker": "Maya", "startTime": 0, "endTime": 7, "body": "Welcome to Spoke and Sprocket. Today I'm talking with Dana Ortiz." },
    { "speaker": "Dana", "startTime": 7, "endTime": 10, "body": "Thanks for having me." }
  ]
}

This is the richest format for apps, because they can search it and show the speaker without parsing text.

Which format should you publish?

A ✓ means the format carries it. SRT has no speaker field, so names are added by convention. HTML timing is optional.

A sensible default for a small show is to keep one timestamped text file as the master, publish an HTML version on the episode page, and offer WebVTT through your feed.

Attach it to your RSS feed

The Podcasting 2.0 tag podcast:transcript sits inside an episode's <item>. It requires two attributes, url for where the transcript file lives and type for its format. According to the documentation, the supported types include text/plain, text/html, text/vtt, application/json and application/x-subrip. An optional language attribute defaults to the feed's language, and rel="captions" marks a file that carries timecodes as closed captions. You can add several tags to one episode, for example WebVTT and HTML.

<item>
  <title>Why we closed the second shop</title>
  <podcast:transcript url="https://example.com/ep12/transcript.vtt" type="text/vtt" language="en" rel="captions" />
  <podcast:transcript url="https://example.com/ep12/transcript.html" type="text/html" />
</item>

The podcast prefix has to be declared on the feed's root element with xmlns:podcast="https://podcastindex.org/namespace/1.0". Many hosts add the tag for you when they generate transcripts, so check your host's settings before editing the feed. Our comparison of transcription software lists which hosts include transcripts.

Convert one file into WebVTT and JSON

This script reads the timestamped format above and writes a .vtt and a .json file next to it. The end time of each segment is the start of the next one, and the last segment gets five seconds, so a long pause before the next turn shows up as a long segment. It is a starting point and not a captioning tool.

"""Turn a timestamped, speaker-labeled transcript into WebVTT and Podcasting 2.0 JSON."""
import json
import re
import sys
from pathlib import Path

LINE = re.compile(r"^\[(\d+):(\d{2}):(\d{2})\]\s*([^:]+):\s*(.+)$")


def parse(text):
    segments = []
    for line in text.splitlines():
        match = LINE.match(line.strip())
        if not match:
            continue
        hours, minutes, seconds, speaker, body = match.groups()
        start = int(hours) * 3600 + int(minutes) * 60 + int(seconds)
        segments.append({"speaker": speaker.strip(), "startTime": start, "body": body.strip()})
    for current, following in zip(segments, segments[1:]):
        current["endTime"] = following["startTime"]
    if segments:
        segments[-1]["endTime"] = segments[-1]["startTime"] + 5
    return segments


def stamp(total):
    return f"{total // 3600:02d}:{total % 3600 // 60:02d}:{total % 60:02d}.000"


def to_vtt(segments):
    lines = ["WEBVTT", ""]
    for seg in segments:
        lines.append(f"{stamp(seg['startTime'])} --> {stamp(seg['endTime'])}")
        lines.append(f"<v {seg['speaker']}>{seg['body']}")
        lines.append("")
    return "\n".join(lines)


def to_json(segments):
    return json.dumps({"version": "1.0.0", "segments": segments}, indent=2)


if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit("usage: convert_transcript.py <transcript.txt>")
    source = Path(sys.argv[1])
    segments = parse(source.read_text(encoding="utf-8"))
    if not segments:
        sys.exit("no lines matched the [HH:MM:SS] Speaker: text pattern")
    source.with_suffix(".vtt").write_text(to_vtt(segments), encoding="utf-8")
    source.with_suffix(".json").write_text(to_json(segments), encoding="utf-8")
    print(f"wrote {source.with_suffix('.vtt').name} and {source.with_suffix('.json').name} ({len(segments)} segments)")

Save it as convert_transcript.py, put your transcript in episode.txt with lines like [00:01:42] Dana: text, and run python3 convert_transcript.py episode.txt. On the four invented lines above it wrote both files. A speaker name that contains a colon will break the pattern, so avoid colons in labels.

Clean it before you publish

Run through this list on every transcript:

• Check every guest and brand name against the guest's own spelling.
• Make speaker labels consistent, with one label per person.
• Decide on fillers, and apply the choice everywhere.
• Split long turns into paragraphs.
• Read the first two minutes against the audio to confirm the timestamps line up.

Once it is clean, the transcript is also the source for your show notes, and for finding ideas across episodes, as in our guide to finding episode ideas in your own transcripts.

Questions people ask

Should I publish a full transcript on my site? It gives search engines text to index and helps readers who prefer text. Put it on the episode page, and add a short summary above it.

What is the best format for a podcast transcript? Keep a timestamped text file as your master, since you can convert it to the others. Publish HTML for readers and WebVTT for apps.

What is the difference between SRT and WebVTT? Both are caption formats. SRT uses a comma before the milliseconds and numbered cues. WebVTT uses a period, needs a WEBVTT header and supports voice tags for speakers.

Do I need a transcript for accessibility? Transcripts help listeners who are deaf or hard of hearing. Check the accessibility requirements that apply to your organization or platform.