How to Create SRT and VTT Subtitle Files from a Transcript

SPEAKER_00 [00:00:01.000 - 00:00:05.240]: Thanks for coming in today.
SPEAKER_01 [00:00:05.900 - 00:00:11.480]: No problem at all, happy to help.
SPEAKER_00 [00:00:12.010 - 00:00:19.750]: Let's start with how you first heard about us.

import re

LINE = re.compile(
    r"^(?P<speaker>SPEAKER_\d+) "
    r"\[(?P<start>\d{2}:\d{2}:\d{2}\.\d{3}) - "
    r"(?P<end>\d{2}:\d{2}:\d{2}\.\d{3})\]: "
    r"(?P<text>.*)$"
)


def parse_segments(diarization: str) -> list[dict]:
    """Turn the diarization string into a list of timed segments."""
    segments = []
    for line in diarization.splitlines():
        match = LINE.match(line.strip())
        if match:
            segments.append(match.groupdict())
    return segments

def to_srt(segments: list[dict], include_speakers: bool = True) -> str:
    blocks = []
    for index, seg in enumerate(segments, start=1):
        # SRT timecodes use a comma before the milliseconds.
        start = seg["start"].replace(".", ",")
        end = seg["end"].replace(".", ",")
        text = seg["text"]
        if include_speakers:
            text = f"{friendly(seg['speaker'])}: {text}"
        blocks.append(f"{index}\n{start} --> {end}\n{text}\n")
    return "\n".join(blocks)


def friendly(speaker: str) -> str:
    """SPEAKER_00 -> Speaker 1. Map to real names where you know them."""
    names = {"SPEAKER_00": "Interviewer", "SPEAKER_01": "Participant"}
    if speaker in names:
        return names[speaker]
    return f"Speaker {int(speaker.rsplit('_', 1)[1]) + 1}"

def to_vtt(segments: list[dict], include_speakers: bool = True) -> str:
    lines = ["WEBVTT", ""]
    for seg in segments:
        text = seg["text"]
        if include_speakers:
            # VTT understands voice spans, which players can style per speaker.
            text = f"<v {friendly(seg['speaker'])}>{text}</v>"
        lines.append(f"{seg['start']} --> {seg['end']}")
        lines.append(text)
        lines.append("")
    return "\n".join(lines)

MAX_CHARS = 84  # two lines of ~42


def split_segment(seg: dict, max_chars: int = MAX_CHARS) -> list[dict]:
    """Split one long segment into several cues sharing its time span."""
    text = seg["text"]
    if len(text) <= max_chars:
        return [seg]

    # Prefer sentence boundaries, fall back to word boundaries.
    parts, current = [], ""
    for token in re.split(r"(?<=[.!?,])\s+", text):
        if current and len(current) + len(token) + 1 > max_chars:
            parts.append(current)
            current = token
        else:
            current = f"{current} {token}".strip()
    if current:
        parts.append(current)

    start, end = to_seconds(seg["start"]), to_seconds(seg["end"])
    step = (end - start) / len(parts)
    return [
        {
            "speaker": seg["speaker"],
            "start": to_timecode(start + i * step),
            "end": to_timecode(start + (i + 1) * step),
            "text": part,
        }
        for i, part in enumerate(parts)
    ]


def to_seconds(tc: str) -> float:
    h, m, s = tc.split(":")
    return int(h) * 3600 + int(m) * 60 + float(s)


def to_timecode(seconds: float) -> str:
    h, rem = divmod(seconds, 3600)
    m, s = divmod(rem, 60)
    return f"{int(h):02d}:{int(m):02d}:{s:06.3f}"

import requests, time

HEADERS = {"X-API-Key": "sk_live_..."}
BASE = "https://api.icana.ai/api/v1"

with open("episode.mp3", "rb") as f:
    job = requests.post(
        f"{BASE}/transcribe",
        headers=HEADERS,
        files={"file": f},
        data={"num_speakers": 2},
    ).json()

while True:
    result = requests.get(f"{BASE}/jobs/{job['id']}", headers=HEADERS).json()
    if result["status"] in ("completed", "failed"):
        break
    time.sleep(5)

segments = parse_segments(result["diarization"])
cues = [c for seg in segments for c in split_segment(seg)]

open("episode.srt", "w").write(to_srt(cues))
open("episode.vtt", "w").write(to_vtt(cues))