Transcribe

Transcribe is a community skill for converting audio and video recordings into text using speech-to-text APIs and local models, covering transcription configuration, speaker identification, timestamp generation, and output formatting.

What Is This?

Overview

Transcribe provides patterns for converting spoken audio into structured text output. It covers API-based and local model transcription, audio preprocessing for quality improvement, speaker diarization for multi-speaker recordings, timestamp alignment at word and segment levels, and output formatting into SRT subtitles, plain text, and JSON structures. The skill handles the full pipeline from raw audio input to formatted, usable text output.

Who Should Use This

This skill serves developers building transcription features into applications, content teams producing subtitles and captions from video recordings, and researchers converting interview and meeting recordings into searchable text for analysis.

Why Use It?

Problems It Solves

Manual transcription is prohibitively slow, taking three to four hours per hour of audio. Raw API transcription output lacks formatting, speaker labels, and paragraph breaks that make text usable. Audio quality variations from different recording sources require preprocessing to achieve acceptable accuracy. Multi-speaker recordings produce undifferentiated text blocks without diarization processing.

Core Highlights

Multi-format input handles audio files in MP3, WAV, M4A, and video files with audio track extraction. Word-level timestamps enable precise subtitle generation and audio navigation. Speaker diarization segments transcript by speaker for meeting and interview recordings. Output formatters produce SRT, VTT, plain text, and structured JSON from the same transcription result.

How to Use It?

Basic Usage

import httpx
from pathlib import Path
from dataclasses import dataclass, field

@dataclass
class TranscriptSegment:
    text: str
    start: float
    end: float
    speaker: str = ""

@dataclass
class Transcript:
    segments: list[TranscriptSegment] = field(default_factory=list)
    language: str = ""
    duration: float = 0.0

    def full_text(self) -> str:
        return " ".join(s.text for s in self.segments)

    def by_speaker(self) -> dict[str, list[str]]:
        grouped = {}
        for seg in self.segments:
            speaker = seg.speaker or "unknown"
            grouped.setdefault(speaker, []).append(seg.text)
        return grouped

class TranscriptionClient:
    def __init__(self, api_key: str):
        self.client = httpx.Client(
            headers={"Authorization": f"Bearer {api_key}"},
            timeout=300.0
        )

    def transcribe(self, audio_path: str, language: str = "en") -> Transcript:
        with open(audio_path, "rb") as f:
            resp = self.client.post(
                "https://api.openai.com/v1/audio/transcriptions",
                data={"model": "whisper-1", "language": language,
                      "response_format": "verbose_json",
                      "timestamp_granularities[]": "segment"},
                files={"file": f}
            )
        data = resp.json()
        segments = [
            TranscriptSegment(text=s["text"], start=s["start"], end=s["end"])
            for s in data.get("segments", [])
        ]
        return Transcript(segments=segments, language=data.get("language", ""),
                         duration=data.get("duration", 0))

Real-World Examples

class SubtitleGenerator:
    def to_srt(self, transcript: Transcript) -> str:
        lines = []
        for i, seg in enumerate(transcript.segments, 1):
            start = self._format_time(seg.start)
            end = self._format_time(seg.end)
            lines.append(f"{i}")
            lines.append(f"{start} --> {end}")
            lines.append(seg.text.strip())
            lines.append("")
        return "\n".join(lines)

    def _format_time(self, seconds: float) -> str:
        h = int(seconds // 3600)
        m = int((seconds % 3600) // 60)
        s = int(seconds % 60)
        ms = int((seconds % 1) * 1000)
        return f"{h:02}:{m:02}:{s:02},{ms:03}"

generator = SubtitleGenerator()
client = TranscriptionClient(api_key="your-key")
transcript = client.transcribe("recording.mp3")
srt_content = generator.to_srt(transcript)
Path("output.srt").write_text(srt_content)

Advanced Tips

Preprocess noisy audio with noise reduction before transcription to improve accuracy. Split long recordings into chunks at silence points to stay within API file size limits. Post-process transcripts with language models to fix punctuation and correct domain terms that the speech model may have misrecognized.

When to Use It?

Use Cases

Generate subtitles for video content published on platforms that require captions. Convert meeting recordings into searchable text notes with speaker attribution. Build podcast indexing tools that make audio content searchable by topic and keyword.

Related Topics

Whisper speech recognition model, audio preprocessing libraries, subtitle format specifications, speaker diarization services, and natural language processing for transcript cleanup.

Important Notes

Requirements

API credentials for a speech-to-text service or a local Whisper model installation. Audio files in supported formats with reasonable recording quality. Sufficient processing time for long recordings that may take minutes to transcribe.

Usage Recommendations

Do: validate transcription accuracy on a sample before processing large batches. Use language hints when the audio language is known to improve recognition accuracy. Store raw transcription output alongside formatted versions for reprocessing.

Don't: assume perfect accuracy for specialized vocabulary, names, or technical terms without post-processing review. Send confidential audio to cloud APIs without confirming data handling policies. Skip audio quality checks before submission, as poor recordings produce unusable transcripts.

Limitations

Transcription accuracy degrades with background noise, overlapping speakers, and heavy accents. Speaker diarization quality depends on clear speaker separation in the audio. Real-time transcription requires streaming API support that not all providers offer at comparable accuracy to batch processing.