I already have a script and a recording. How do I get subtitles that line up?

This page may contain affiliate links from which Blur Studio earns commissions.

Subtitles that drift out of sync, appearing a beat too early or lingering after the line has moved on, make a video feel unpolished even when every word is correct. If you're working from a script you wrote and recorded, re-transcribing the audio from scratch to get subtitles is solving a problem you don't have: you already know exactly what was said. What you actually need is timing, not transcription, and paying for a tool that re-figures out words you've already written is both unnecessary cost and an extra step that can introduce new errors you didn't have before.

Forced alignment is the right tool for exactly this

Forced alignment takes text you already have and matches it to the audio, returning precise, word-level timestamps for when each word is actually spoken. ElevenLabs' Forced Alignment tool does this at the same $0.22-an-hour rate as its standard Speech to Text, and handles files up to 3GB, 10 hours of audio, or 675,000 characters of text in a single job, which covers nearly anything short of a full-length feature film.

The honest caveat: it's an API-only tool. There's no dashboard upload-and-download interface for it; using it means either writing a small script yourself, hiring someone to, or using a tool built on top of the API that exposes this feature through a simpler interface. If that's more technical setup than you want, the alternatives below are more approachable.

A concrete look at what comes back helps make this less abstract. Send the API a sentence like "Welcome back to the show, today we're talking about pricing" alongside the matching audio, and it returns a timestamp for every single word: when "Welcome" starts and ends, when "back" starts and ends, and so on through the sentence, down to fractions of a second. That's a meaningfully different, more precise output than most auto-captioning tools give you, which typically time whole phrases or sentences rather than individual words. Word-level timing is what lets you build subtitles that highlight word by word as they're spoken (common in social video captions), not just phrase-level subtitles that appear and disappear as a block.

Turning timestamps into an actual subtitle file

The API gives you raw timing data, not a finished subtitle file; converting that into something your video player or platform actually reads is a separate, small step. The most common target format is SRT, a simple text format that pairs a block of text with a start and end time. You'll typically group the word-level timestamps back into readable phrase-length chunks (a handful of words at a time, timed to when the first and last word in that chunk were spoken), rather than displaying a new subtitle for literally every single word, since that reads as flickering rather than readable captions. Most platforms (YouTube, most video editors, most webinar tools) accept standard SRT files directly, so once you've built this conversion step once, it's reusable for every future piece of content with the same format.

The more approachable alternatives

• Subtitle editors: most dedicated subtitle-editing tools let you load your script and recording side by side and manually nudge timing until it matches, which works well for shorter videos where the manual time investment is small.
• Your video editor's built-in captioning: many video editing tools can auto-generate captions from audio directly, which you can then correct against your known script, skipping the forced-alignment step entirely for shorter or lower-stakes videos.

What I'd actually tell someone with a script already in hand

If you're doing this occasionally, for a handful of videos, manual alignment in a subtitle editor is genuinely fine and doesn't need any technical setup. Forced alignment through the API earns its place once you're doing this often enough, many videos, a recurring training series, a podcast with a published transcript, that the manual nudging adds up to real time across every piece of content, and precise, consistent timing matters enough to be worth the one-time setup cost of wiring up the API.

Step by step, if you go with forced alignment

1. Confirm your script text matches what was actually said in the recording; forced alignment matches text to audio, so it can't correct a script that diverges from the real recording. Listen through once with the script in front of you specifically to catch this, rather than assuming a clean written script and a clean recording automatically match.
2. Send the audio and the matching script text to the Forced Alignment API, either directly or through a tool built on it. Clean audio gives better results, so clean up the recording first.
3. Take the returned word-level timestamps and format them into your subtitle file format (commonly SRT), grouping words into readable phrase-length chunks rather than one subtitle per word.
4. Watch the finished video with subtitles on to confirm the timing feels right, not just technically present, since a timestamp can be technically correct and still read awkwardly if the phrase grouping doesn't match how someone would naturally read along.

Why precise timing is worth the effort at all

It's fair to ask whether subtitle precision at the word level actually matters versus "close enough" phrase-level timing from an auto-captioning tool. For most casual viewing, close enough is genuinely fine. Where precision earns its keep is accessibility: a viewer relying on captions to actually understand the video, rather than as a casual add-on, notices drift between what's said and what's on screen far more than a casual viewer does, and that drift is exactly what makes captions feel unreliable enough that some people stop trusting them. It also matters for any video where exact wording carries legal or compliance weight, a disclosure, a terms explanation, a safety instruction, since a subtitle that's slightly out of sync with the audio can create genuine ambiguity about what was actually said and when. If your content is casual and the audience is watching with sound on anyway, don't over-invest in this; if captions are genuinely load-bearing for part of your audience, the precision is worth the setup.

When to skip this

If your script and the actual recording diverge in places (ad-libs, cut lines, re-takes with slightly different wording), forced alignment will struggle, since it's matching text to audio, not generating new text. In that case, a standard transcription pass, treating the recording as the source of truth instead of the script, is the more reliable approach.

A smaller, more common version of this problem is worth knowing too: a single skipped word, a stumble that got re-recorded mid-line, or an ad-libbed aside that isn't in the written script. This doesn't necessarily mean the whole approach fails, but it does mean that section of alignment is likely to come back wrong or misaligned, since the tool is still trying to match text that doesn't fully correspond to what's on the recording at that point. If you know roughly where these small divergences happen, it's worth manually correcting the script to match what was actually said in those specific spots before sending it for alignment, rather than discovering the mismatch only after the timestamps come back off for that section. For a video with many small ad-libs throughout, at some point a full transcription pass becomes less work than patching the script to match dozens of small deviations.

Multi-speaker scripts (an interview, a panel, a two-host podcast) add one more wrinkle: forced alignment matches text to audio, but it's worth checking whether your specific implementation also tracks which speaker said which word, since that matters for subtitle formatting (showing who's talking) as much as timing does. If speaker attribution isn't part of what comes back, you may need to pair this with a separate transcription pass that does include speaker labels, then use the alignment data just for precise timing on top of that.

How I'd approach this

This is a genuinely small, specific piece of automation, exactly the kind of thing worth building once into a repeatable pipeline if you're publishing scripted video or audio content regularly: script in, recording in, correctly timed subtitles out, with no manual nudging per episode. For occasional use, I'd point you at a subtitle editor first and only build the automated version once the manual process is clearly costing real time across many pieces of content. When I do build it, the pipeline usually includes the formatting step too, grouping word-level timestamps into clean SRT chunks automatically, so the output is a finished, ready-to-upload subtitle file rather than raw timing data someone still has to hand-convert every episode.