Podcast episodes, transcribed verbatim.

Podcast transcription turns the audio of an episode into text that keeps the timing, so it can be searched, quoted, captioned and linked to the second. Every transcript Tapeclerk returns carries the same five things:

• Segments with timecodes: start and end offset of every spoken passage, to the millisecond, in the order they were spoken.
• Speaker turns: who is talking, so an interview reads as one.
• Chapter marks: the passage boundaries an editor would cut, at the timecodes a player can jump to.
• Show notes with verbatim quotes: lines lifted out of the transcript word for word, never rewritten.
• The same output in five formats: JSON, plain text, SRT, VTT and Markdown, from one set of segments.

Accepted links

Apple Podcasts episode and show links, Spotify episode and show links, an RSS feed URL, a YouTube video link, or a direct .mp3 / .m4a / .wav file.

Audio handling

Whatever the publisher serves is decoded and resampled to 16 kHz mono PCM before the model sees it, so the model always gets the same input format. Downloads are capped at 400 MB and stopped mid-stream at the cap, not after it.

Engine

NVIDIA Parakeet TDT 0.6B v3 for the words, with Silero voice-activity detection, and a pyannote segmentation model with TitaNet speaker embeddings for who said them, all through sherpa-onnx on our own GPU. No third-party speech API is in the request path.

Languages

Whichever language the loaded model is for. If the audio comes back in a language that model is not configured for, the answer is LANG_UNSUPPORTED rather than a transcript in the wrong language.

Episode limits

4 hours of audio per episode. Longer recordings are split into parts and the transcripts stitch back in order.

Cost

One credit per 30 minutes of audio, rounded up: a 63-minute episode costs 3 credits. A run that does not produce a transcript costs nothing. A new account starts with 6 credits.

Retention

The fetched audio is deleted by the step that writes the transcript. Nothing is used to train a model.

ffmpeg -ss 00:11:02 -t 45 -i episode.mp3 -ac 1 -ar 16000 clip16.wav
sherpa-onnx-offline --model-type=nemo_transducer --encoder=parakeet/encoder.onnx \
  --decoder=parakeet/decoder.onnx --joiner=parakeet/joiner.onnx \
  --tokens=parakeet/tokens.txt clip16.wav
sherpa-onnx-offline-speaker-diarization --clustering.num-clusters=2 \
  --segmentation.pyannote-model=pyannote/model.onnx \
  --embedding.model=titanet_small.onnx clip16.wav

Two things to note. "nightmote" is left as the model wrote it; a corrected transcript would hide the error. The change of speaker at 11:30 lands a word late, because the diarizer's boundaries sit a few hundred milliseconds off the real ones, so check the turns before you publish.

1. Resolve: what kind of link is this?

   An Apple episode link is not an audio URL, and neither is a Spotify one. Tapeclerk classifies the link first, then goes and gets the episode's own enclosure: for Apple, the title, show and duration come off the episode page's JSON-LD, the show's feed comes from the iTunes lookup API, and the audio comes from the RSS item whose title, duration and publish date match the episode. An RSS or mp3 link skips all of that and is used as given.

2. Fetch: audio and metadata

   The enclosure is streamed, not buffered, with a byte cap that stops the request mid-stream rather than after the fact. Requests identify themselves as a browser where a platform requires it, follow a bounded number of redirects, and cache feed metadata for 15 minutes. Anything that answers 401 or 403 is reported as AUTH_REQUIRED and not retried.

3. Transcribe: speakers, chapters, timecodes

   Audio is decoded to 16 kHz mono, cut at the pauses Silero finds into windows under a minute, and decoded by Parakeet on the GPU with a time on every token. A separate speaker pipeline draws who spoke when, and each word takes the speaker whose region covers it. The segments come out with the offsets the models reported; the render step is what turns them into JSON, text, SRT, VTT and Markdown.

SRT or VTT for a podcast?

SRT if a human is going to open it in an editor, VTT if a browser is going to load it. SRT is the oldest and most widely imported caption format: index, timing line, two lines of text, blank line. VTT is its successor for the web: a header line, a dot rather than a comma before the milliseconds, and cue settings such as position and styling, which SRT cannot express. If you publish the episode on a site with a <video> or <audio> element, VTT is the one the player will read.

No credits are charged for any of them. A run costs nothing unless a transcript came out of it.

curl -X POST https://tapeclerk.com/api/v1/transcriptions \
  -H "authorization: Bearer tc_live_…" -H "content-type: application/json" \
  -d '{"url":"https://podcasts.apple.com/us/podcast/id1528594034?i=1000786488728","speakers":2}'

HTTP/1.1 202 Accepted
{"job_id":"tc_pfuW21mY9BbIFGiKgA83fQ","code":"RESOLVED","status":"queued",
 "episode":{"show":"Hard Fork","title":"Meta Shifts the Blame …","duration_s":3776},
 "credits_cost":3,"status_url":"/api/v1/jobs/tc_pfuW21mY9BbIFGiKgA83fQ"}

The key comes with an account; the form at the top of this sheet uses your signed-in session instead. New accounts start with 6 credits, enough for three hours of audio; write to us for more. Without a key or a session every endpoint answers 401 AUTH_REQUIRED, and a job the account cannot pay for is refused with 402 NO_CREDITS before anything runs. speakers is optional and is a floor, not a count: the diarizer groups the voices it hears, and the number only forces a count when it hears fewer. Ads, jingles and clips are voices too, so a two-host show usually files with more than two. You get a 202 and a job, not an estimate of how long the run takes. Poll the status URL: queued, fetching, transcribing, done, each stage with the time it was reached. When the job files, the transcript is at /api/v1/jobs/<id>/transcript/json, and the same segments as txt, srt, vtt and md. A run that files nothing costs nothing.

The fetched file is deleted by the same step that writes the transcript, in the same function, before the job reports done. The workspace has a byte cap, so a run cannot fill a disk on its way to being deleted. Audio is not used to train anything, and no speech API is in the path; the model runs on a machine we control.

The longer version, including which code deletes the file and how to check, is on sheet 2, how we do it.