Reading speed
Characters per second counts every visible character, spaces included. Over 20 CPS a viewer either misses the line or pauses, and on a phone the second option does not exist.
Open SRT, WebVTT, SBV or a plain transcript. CaptionSync measures the reading speed, line length, overlaps and gaps that fail QC, and removes 23.976 to 25 fps drift with a real factor instead of a guess. Your subtitle file and your video never leave this tab.
Everything below runs on this device. Load a file, read the audit, repair what it finds, export.
No file loaded. Use the drop zone above, load a sample, or press New to start from an empty sheet.
Every one of them is measurable. CaptionSync measures them on every keystroke, so you see the problem while you can still fix it in context.
Characters per second counts every visible character, spaces included. Over 20 CPS a viewer either misses the line or pauses, and on a phone the second option does not exist.
42 characters per line and two lines is the working ceiling for streaming. A third line covers the picture it is supposed to support, and a 60 character line wraps wherever the player feels like it.
Two cues on screen at once is almost always an editing accident. The audit finds every cue that starts before its predecessor ends, including the ones hidden inside a long block.
Under 83 ms (two frames at 24 fps) the change reads as a flicker. The default gap check finds those, and the fix makes room without moving the line that follows.
A cue under 0.83 seconds cannot be read unless it is a single word, and a cue over 7 seconds invites the viewer to re-read it and lose the thread. Both are flagged.
A file timed for 25 fps used on a 23.976 fps master is 2 minutes 34 seconds late after one hour. The FPS tool applies the exact ratio, not a rounded guess.
Drop the file. The format is detected, the cue count and total duration appear, and any block the parser could not read is named instead of silently dropped.
Check the last cue against the picture. If the error grows, apply the frame rate factor; if it is constant, use the offset tool. Two point sync handles files that were retimed by hand.
Run the audit, then the auto-fix. Overlaps, gaps, wrapping and sound tags are repaired in one pass, with an undo that restores the original file exactly.
Drop the video, play through the joins, and set any cue that lands late at the playhead. Export SRT, VTT, SBV or TXT and open the result once in the target player.
A subtitle file looks like a small text file and behaves like a technical document. It has a clock, a reading budget, a layout budget and a delivery format, and each one fails in a different way. This guide is the order we use in the studio: identify the master, separate offset from drift, read the audit the way a QC operator does, repair without rewriting, and convert only at the end.
The first problem is timing. A line has to appear when the sound happens, and disappear before it becomes furniture. The second is readability. Even a perfectly timed line can be unreadable if it contains too many characters for the time it is on screen, or if it is broken in a place that forces the eye to jump. Most subtitle complaints online are about the first problem, because it is the one a viewer notices consciously. The second problem is quieter: the viewer does not report it, they just stop reading and listen instead.
Fixing them in the wrong order wastes work. If you rewrap and shorten lines first, then discover the file is 4 percent fast, every timing decision you made was against the wrong clock. So start with timing, and start timing with the master.
Ask for two numbers: the exact runtime and the frame rate of the file you are delivering against. Not the frame rate in the brief, which is often copied from an older delivery, and not the frame rate of the file the subtitles came from, which may be different. The common rates are 23.976 (film shot at 24 but stored as 24000/1001), 24, 25 (PAL and much of European broadcast), 29.97 (NTSC, 30000/1001) and 30. The difference between 23.976 and 24 is one tenth of a percent, which is 3.6 seconds per hour. The difference between 23.976 and 25 is 4.27 percent, which is 2 minutes 34 seconds per hour. Both are invisible in the first minute and unmissable in the last.
A practical test: find two hard sync points, one near the start and one near the end. A door slam, a cut to black, a hand clap, a gunshot. If the first cue is uniformly early or late and the last cue is off by the same amount, you have a constant offset. If the error at the end is larger than the error at the start, you have speed drift. If the first cue is right and the error grows in one direction, the file was timed against a different cut of the same programme.
Offset and drift are two different transforms. An offset adds a constant to every timestamp. Drift multiplies every timestamp by a factor, because a video that runs 4 percent faster compresses the whole timeline toward zero. That difference matters: if you add 30 seconds to a file and then multiply everything by 1.04, you have also multiplied the 30 seconds, and the first cue is now 1.2 seconds wrong. The clean order is scale first, then trim the residual offset.
In CaptionSync the frame rate panel shows the factor before it touches anything. 25 divided by 23.976 is 1.042709, and the panel states what that does at the one hour mark. Apply it, check the last cue again, and only then use the offset tool for the small remainder. If the file is already at the right speed but uniformly late, skip the scale entirely: a factor of 1.0 is a no-op, and the offset panel is the right tool.
QC is not a matter of taste. The Netflix timed text style guide, which most streaming workflows borrow from, gives a small set of hard numbers: 20 characters per second, 42 characters per line, two lines per cue, a minimum duration of 5 frames at 24 fps (about 208 milliseconds for the cue itself, with 0.83 seconds as the practical reading floor), a maximum duration of 7 seconds, and a gap of at least 2 frames (83 milliseconds) between consecutive cues. Broadcasters vary the edges, but the shape is the same everywhere: a viewer has a limited number of eye movements per minute and a limited number of characters per fixation.
The two numbers that catch the most files are CPS and CPL, and they catch different mistakes. A cue with 24 CPS and one short line means the line is on screen for too little time: either the duration is wrong or the text belongs in two cues. A cue with 15 CPS but a 58 character line passes the speed check and fails the layout check, because the player will wrap it wherever it wants, often leaving a single word on the second line. Both are visible in the cue badges as you edit, so you can fix the line while you are looking at it rather than exporting and re-importing.
Wrapping is the least destructive fix and the easiest to get wrong. The goal is not to hit 42 characters; the goal is to break the line where a reader would pause. Keep a name together. Keep a number and its unit together. Do not end a line on an article or a preposition if the next line can hold it. If a cue has two speakers, keep one speaker per line, even if the result is shorter than the limit, because a dash at the start of a line is a visual cue that someone else is talking.
CaptionSync wraps by minimising the imbalance between lines at the minimum line count that fits, so a 60 character cue becomes two lines of roughly 30 rather than a 42 and an 18. It never changes words, and it never splits a word unless the word alone is longer than the limit. The result is a suggestion, not a verdict: read the two-line version once before you accept it, especially on comedy, where the line break is part of the timing of the joke.
Two speakers in one cue need a visual separator. The convention is a hyphen at the start of each speaker's line, with one speaker per line, and no blank line between them. Do not use a hyphen to indicate a pause in a single speaker's line; that is what the comma and the ellipsis are for. If three people speak in the same two seconds, the cue is doing too much and should be split.
Bracketed descriptions such as [SFX], [DOOR SLAMS] or [MUSIC] belong to a subtitles-for-the-deaf-and-hard-of-hearing track, not to a standard translation track. Many platforms reject them in the main track or display them as dialogue. CaptionSync's fix removes bracketed segments that are entirely capitalised or that name a common sound, and leaves bracketed text that looks like a real word or a product name. If you are producing an SDH track on purpose, turn that fix off and keep the descriptions.
SRT is the safest interchange format: cue number, timecode with a comma before the milliseconds, text, blank line. WebVTT is the web format: a WEBVTT header, a dot before the milliseconds, optional cue identifiers and optional settings such as align and position. SBV is the older YouTube format: one line with both timecodes separated by a comma, no cue numbers, single digit hour. TXT is not a subtitle format at all, but a transcript is often what you are given, and a transcript is a useful starting point when there is no timecode to inherit.
Convert once, at the end, after the timing and the wrapping are settled. Converting back and forth loses information: SRT has nowhere to store VTT cue settings, and a text export throws away timing entirely. Keep the working file in the format it arrived in, export the delivery format, and open the exported file once in the player the client will use. A file can be perfect in an editor and still be rejected by a platform that expects UTF-8 without a byte order mark, or LF line endings, or a WEBVTT signature on the first line.
Unreleased footage is confidential material. A subtitle file is a transcript of that footage, which makes it just as sensitive: it reveals dialogue, names, jokes and plot points before release. The safest workflow is the one where the file never leaves the machine. CaptionSync reads files with the browser File API and keeps them in the memory of the tab. A dropped video becomes a Blob URL that the browser plays from disk. There is no upload, no account, no analytics product reading the text and no storage; closing the tab discards the work, so export before you close it. The only third party script on the page is the advertising script, and it does not receive your cues.
| Authored for | Video plays at | Factor | Shift after 1 hour |
|---|---|---|---|
| 23.976 | 24 | 0.999000 | -3.6 s |
| 24 | 25 | 0.960000 | -2 min 24 s |
| 25 | 23.976 | 1.042709 | +2 min 33.8 s |
| 23.976 | 25 | 0.959041 | -2 min 27.5 s |
| 29.97 | 30 | 0.999000 | -3.6 s |
| 30 | 29.97 | 1.001001 | +3.6 s |
The defaults in the audit are the Netflix timed text style guide values, which have become the common language of streaming QC: 20 CPS, 42 characters per line, 2 lines, 7 seconds maximum, 5 frames minimum with a 0.83 second reading floor, and a 2 frame gap. BBC, ITV and most European broadcasters use variants of the same limits. YouTube does not publish a strict CPS ceiling for uploaded subtitles, but its player, its phone layout and its auto-caption editor all behave better under the same constraints. If your client gives you different numbers, change them in the audit panel: the checks and the auto-fix both follow your limits, not ours.
No. Files are read with the browser File API and kept in the memory of the tab. A dropped video becomes a local Blob URL, which the browser plays from disk. There is no server on this site that receives files, no account, and no storage: closing the tab discards everything. The only outside script is Google AdSense, which renders ads and does not receive your subtitle text.
You can open SRT, WebVTT, SBV and plain text transcripts, and export any of those four. The parser detects the format from the file extension and the content, so a file with a wrong extension usually still opens. WebVTT cue settings such as align and position are preserved when you export back to VTT.
A subtitle file is timed against one cut of a video. If that cut runs at 23.976 fps and the version you are watching runs at 25 fps, every minute of the 25 fps version happens 4.27 percent earlier, so an error that is invisible at the start becomes minutes by the end. CaptionSync multiplies every timestamp by the ratio of the two frame rates (for example 25 divided by 23.976, a factor of 1.042709). That is a linear transform anchored at zero, which matches how a speed change works. If the file also has a constant late or early offset, move the whole file by the remaining difference afterwards.
CPS is characters per second, the reading speed of a cue, counting every visible character including spaces but not line breaks. CPL is characters per line, the longest line in the cue. Twenty CPS is the ceiling in the Netflix timed text style guide, and 42 characters is its line limit. Those two numbers have been the de facto ceiling for broadcast and streaming subtitles for years because they keep a two line cue readable on a phone without pausing the picture. CaptionSync uses them as defaults and lets you change both.
Yes, the Netflix timed text style guide limits a subtitle line to 42 characters and a cue to 20 characters per second, two lines and a minimum duration of 5 frames (about 0.2 seconds) with a 2 frame gap between cues. Many other broadcasters use the same family of numbers. YouTube does not publish a strict CPS limit for uploaded subtitles, but its player and phone layouts still reward short lines and two lines at most, so a 42 character target is a safe common denominator rather than a YouTube rule.
Two frames at 24 fps is about 83 milliseconds. If one cue ends less than that before the next begins, the change reads as a flicker rather than a new line, especially on a large screen. CaptionSync flags gaps under 83 ms by default and the auto-fix pulls the later cue forward or trims the earlier one so the gap exists. A longer gap is fine: it gives the viewer a moment to look back at the picture.
The auto-fix only normalises whitespace, removes bracketed sound descriptions such as [SFX] or [DOOR SLAMS], rewraps each cue to the character limit with balanced line lengths, resolves overlaps and gaps, and optionally clamps cue durations to your minimum and maximum. It never substitutes words, removes dialogue or translates anything. Wrapping moves line breaks, which can change how a joke lands, so read the result before you export. Undo restores the file exactly as it was.
Yes. The offset tool can move all cues, only the cues you tick, or every cue whose start time falls inside a time range. That covers the common repair where the first half is right and a reel change in the middle pushes everything after it. Frame rate correction and two point sync apply to the whole file, because a speed change affects every timestamp.
Yes. Once the page has loaded, a service worker keeps the app shell on your device. You can open an installed copy without a network connection, load a file, fix it and export it. Ads require a connection, but every editing feature works offline.
Drop an MP4, WebM, MOV, MP3 or WAV file onto the media panel. The browser plays it from a local Blob URL, the cue that matches the playhead is highlighted in the list, and its text appears over the picture with a safe area guide. The file is never uploaded. You can also set a cue start or end to the current playhead, which is faster than typing timecodes.
Yes. There is no paid tier, no account and no export limit. The site is supported by advertising. Because everything runs in your browser, there is no per minute processing cost to pass on.
Check four things: the first, middle and last cue against the picture, so timing is verified at both ends; the audit, with zero overlaps and zero cues under the gap and duration limits; the longest line and the highest CPS, which should sit under your client's limits; and the exported file opened once in the target player, because a file that looks right in an editor can still be rejected by a platform. Also confirm the frame rate of the delivered master, not the one in the brief.
Each guide takes one problem, shows the arithmetic behind it, and ends with the exact settings that fix it.
Why a file drifts, how to tell drift from offset, the exact factors, and how to verify a correction at both ends of a feature.
Read the guide Guide 02The numbers behind the audit, how they are counted, where platforms differ, and how to keep a cue readable on a phone.
Read the guide Guide 03Syntax side by side, what survives a conversion, encoding rules, and the checks that stop a platform rejection.
Read the guide