How to Automate Subtitle Extraction on Mac (2026): AI Agents, Watch Folders & Local Pipelines

TL;DR: How much of subtitle extraction you can automate depends on which of the three subtitle types you have. Toggleable subtitle tracks inside MKV/MP4 files are one ffmpeg command — fully scriptable. Videos with no subtitles at all are handled by speech recognition: Whisper runs locally from the command line, or GeekLink's Watch Folder auto-transcribes and translates every video dropped into a folder, no per-file clicks. Burned-in subtitles (text baked into the pixels) are the step that resists scripting — there is no mature, maintained open-source OCR pipeline for this on macOS — which is where GeekLink's batch OCR (50+ videos per run, fully local) fills the gap. Every path outputs standard SRT, the universal interface any downstream script, editor, or AI agent can consume.

Why are people automating subtitle extraction in 2026?

Subtitle extraction used to be a one-off task: open an app, load a video, click through. In 2026 it is increasingly a step inside a larger workflow. Creators repurpose whole back catalogs for new languages. Language learners feed sentence-mining tools like subs2srs. Teams wire up AI coding agents — Claude Code, and similar tools — to orchestrate video pipelines end to end: download, extract subtitles, translate, QC, publish.

The moment subtitle extraction becomes a pipeline step instead of a one-off task, the questions change: can it run unattended, can it run in batch, and can a script or AI agent trigger it and pick up the output? This guide answers those three questions honestly for each subtitle type — including the parts where the answer is "not with a script alone."

One constraint shapes everything below: the pipeline stays local. Cloud subtitle APIs exist, but for creators processing hours of footage they meter by the minute, and they require uploading source video — a non-starter for unpublished or client material. Everything in this guide runs on your own Mac, with no video ever uploaded.

Which subtitle types can be extracted automatically?

Every video falls into one of three cases, and each case has a completely different automation story:

• Toggleable subtitles (embedded tracks) — a separate text track inside the container (common in MKV, some MP4). The text already exists as data. Extraction is trivial and 100% scriptable.
• No subtitles — the video only has audio. You need speech recognition. Highly automatable locally, with quality caveats.
• Burned-in subtitles (hardcoded) — the text is part of the picture, common in anime rips, Chinese and Korean variety shows, TikTok/Reels reposts, and older broadcast footage. The original text data is gone; you need OCR against video frames. This is the step that resists DIY scripting.

A useful rule of thumb: if you can turn the subtitles off in a player, one command extracts them; if you can hear speech but see no subtitles, local speech recognition handles it; if the subtitles are part of the image, you need a dedicated OCR tool. If you are not sure which case you have, our embedded vs burned-in guide shows how to tell in ten seconds.

How do you extract toggleable subtitle tracks automatically?

This is the easy case, and you do not need any special tool for it. ffmpeg (free, installable via Homebrew) extracts a subtitle track in one command:

ffmpeg -i input.mkv -map 0:s:0 output.srt

That takes the first subtitle stream (0:s:0) and writes it as SRT. Wrap it in a shell loop and you have batch extraction for a whole folder. Any AI coding agent can write and run this for you — extracting toggleable subtitle tracks is a solved, fully scriptable problem and needs no paid software.

Two caveats worth knowing. First, DVD and Blu-ray subtitle tracks (VobSub/PGS) are stored as images, not text — -map alone cannot convert those to SRT; they need OCR too. Second, many files have multiple tracks in different languages, so list them first with ffprobe before picking an index. Our guides for MKV and MP4 cover the details.

How do you automate speech-to-subtitle transcription on Mac?

When there is no subtitle data at all, speech recognition generates it. On a Mac there are two local automation paths.

Path 1: Script Whisper directly

OpenAI's Whisper is open source and runs from the command line: whisper video.mp4 --model small --output_format srt. It is genuinely scriptable, and if you are already driving your Mac with an AI agent, having it orchestrate Whisper over a folder of videos works. The gaps show up after transcription: raw Whisper output gives you no translation step, no visual check of results against the video, and no way to know which lines it got wrong without watching everything.

Path 2: Watch Folder automation (no scripting)

GeekLink's Watch Folder feature is the no-code version of the same automation. You point GeekLink at a folder once, choose your recognition and translation settings, and every video dropped into that folder afterwards is auto-imported, transcribed, and translated — no per-file clicks, no scripts to maintain. A downloader, an AI agent, or a person can feed the folder; the app does the rest.

This matters for automation because a watched folder is itself an integration point. Anything that can move a file — a yt-dlp script, a Hazel rule, an agent, a network share — can trigger processing without GeekLink exposing an API. Recognition covers 49 languages via Whisper, and translation covers 40+ languages using models you choose (Claude 3.5 Haiku, GPT-4o, GPT-4o mini, DeepSeek), so the folder can output bilingual subtitles, not just transcripts.

Why is burned-in subtitle extraction the hardest step to automate?

Here is the honest part of this guide. If your videos have subtitles baked into the pixels, the "just script it" approach that works everywhere else breaks down. As of 2026 there is no mature, maintained open-source pipeline that reliably turns burned-in subtitles into timed SRT on macOS — the open-source OCR projects in this space are Windows-oriented, GPU-dependent, or unmaintained. (We compare the whole landscape in our hardcoded subtitle extractor roundup.)

The reason a weekend script cannot do it: video OCR is not "screenshot plus text recognition." A naive script that samples one frame per second and OCRs it hits four walls at once:

• Timing precision. Sampling every second means subtitle start and end times can be off by up to a second per line — instantly noticeable against speech.
• Deduplication. A subtitle that stays on screen for three seconds appears in dozens of sampled frames, each OCR'd slightly differently. Merging them into one clean line with correct duration is the actual hard problem.
• Subtitles vs everything else. Watermarks, channel logos, on-screen graphics, and lyrics all look like text to an OCR engine. Without knowing where the real subtitles live, output fills with garbage lines.
• CJK accuracy. Chinese, Japanese, and Korean subtitles — the languages most likely to be burned in — are exactly where generic OCR accuracy drops hardest.

GeekLink's batch OCR is built around those four walls. You draw a box around the subtitle area on the first video — a one-time, ten-second step that tells the engine where subtitles live and what to ignore — and the rest runs unattended. One run processes 50+ videos back to back on your Mac, and each video comes out as a timed SRT, with per-line confidence so you can see what to double-check. The full workflow is in our burned-in subtitle OCR guide.

How does a Mac app fit into an automated workflow without an API?

A fair question from anyone wiring up an agent-driven pipeline: GeekLink is a Mac app, not a command-line tool — so how does it compose with scripts?

The integration contract is the filesystem: files go into a folder, standard SRT files come out, and everything in between runs unattended. Concretely:

• Input side: the Watch Folder accepts anything that lands in it (for speech recognition and translation), and batch import accepts a whole folder at once (for OCR and everything else).
• Output side: exports are standard SRT (also TXT transcripts and subtitle-burned video). SRT is plain text with a stable, decades-old format — any script, editor, translation step, or AI agent downstream can parse it. No proprietary project files to unlock.

To be transparent about limits: GeekLink has no public CLI or HTTP API today. Folder-based automation covers the unattended-batch use case that solo creators and small teams actually run; if programmatic control matters to your workflow, tell us at the GeekLink Discord — hearing real workflows is how we prioritize.

What does a complete local subtitle pipeline look like?

Putting the pieces together, here is a pipeline that handles any mix of videos, entirely on-device:

1. Sort by subtitle type. Check each file: does the player show a subtitle track (toggleable), visible baked-in text (burned-in), or neither (speech)? An agent can do the first check automatically with ffprobe; the other two take a two-second look.
2. Toggleable tracks → ffmpeg. One scripted command per file, done.
3. No subtitles → Watch Folder. Drop the files in; recognition and translation run unattended, with your chosen source and target languages.
4. Burned-in → GeekLink batch OCR. Import the batch, draw the subtitle box once, run. 50+ videos per pass.
5. Collect SRT output. All three paths converge on timed SRT files, ready for whatever comes next — translation, editing, sentence mining, re-embedding, or publishing.

The design principle: automate by routing each video to the right extractor, not by forcing one tool to do everything. ffmpeg is unbeatable for track extraction; Whisper-based recognition handles speech; dedicated OCR handles burned-in text. The SRT format is what lets them compose.

Where does automation still need a human?

An unattended pipeline produces subtitles; it does not guarantee they are right. Names, jargon, overlapping speech, and anything under loud music are where recognition errors cluster — and a fully automated pipeline will happily propagate those errors into your translations and published videos.

The scalable fix is not reading every line — it is having the pipeline flag which lines are likely wrong, so the human review step shrinks from the whole transcript to a shortlist. GeekLink reads the recognizer's per-word confidence and flags the lowest-confidence word in each line, plus segments covered by music, then exports a review pack for the free Subtitle Edit. The end-to-end review workflow is covered in finding the lines AI got wrong.

Budget-wise, the automated pipeline above runs on GeekLink's free tier for trying it out; full batch use is $99/year (~$8.25/month) or $169 lifetime, both including 1M AI translation credits. Requirements: macOS 13.0+ on Apple Silicon (M1–M4).

FAQ

Disclosure: GeekLink is our own Mac app; the Watch Folder, batch OCR, confidence flagging, and translation features described here are GeekLink features. ffmpeg and Whisper are independent open-source projects, not affiliated with us, recommended on their own merits.