Plenty of people scroll with the sound off, on trains, in queues and in bed next to someone asleep. I don't have a reliable statistic for how many, and I won't quote one I can't source. The practical point holds anyway: a short video that only works with sound is a video some viewers will skip. Captions fix that, but bad captions are worse than none. Too small, too fast, too long, hidden behind buttons: the viewer gives up.
This post covers the rules I use for captions on short vertical video, with a Python script that turns timed lines into readable captions and burns them in with ffmpeg. I tested the script, including the rendering. Then I'll describe what Pixasocial says its caption tools do, from its public pages. I haven't used them.
Five rules for readable captions
Keep lines short
Netflix's English style guide allows 42 characters per line and two lines for TV. A phone held upright is much narrower than a TV, so I use about 28 characters per line at a large size, and never more than two lines.
Respect reading speed
The same guide allows up to 20 characters per second for adult programs and 17 for children's. For a quick scroll on a phone I choose the cautious 17. If a caption would need more, cut words. The guide itself advises editing for reading speed by reducing, deleting and condensing text.
Never flash a caption
Give each caption at least a second on screen, and never overlap two captions, or the viewer reads the first half of each.
Keep captions off the app's controls
Social apps place buttons and text along the bottom and side. Lift captions up from the bottom edge, and check the result on a real phone in the real app, because the overlays differ and change.
Get the names and numbers right
Automatic transcripts are where proper nouns, places and dates go wrong. On a history page, a misspelled battle or a wrong year in large white text is the first thing a reader notices. Follow a consistent style for dates: Netflix's guide, for example, writes decades as "1950s" and centuries as "20th century".
The script
The script takes a CSV of start time, end time and text. It wraps each line to 28 characters, splits long lines into pages of at most two lines, shares the available time between the pages in proportion to their length, enforces a minimum duration without ever overlapping the next caption, and prints a warning for any caption faster than the reading limit. It writes a standard SRT file, and can burn the captions into a vertical video with ffmpeg.
captions.py
"""Turn timed transcript lines into readable, sound-off captions (SRT) and burn them into a vertical video.
python captions.py lines.csv out.srt
python captions.py --burn in.mp4 out.srt captioned.mp4
lines.csv columns: start, end, text (seconds or MM:SS.mmm)
"""
import csv
import subprocess
import sys
import textwrap
MAX_CHARS = 28 # per line; Netflix's TV guide allows 42, but this fits a narrow vertical frame at the size below
MAX_LINES = 2
MIN_SECONDS = 1.0 # never flash a caption for less than this
CPS = 17 # Netflix's English style guide allows up to 20 for adult TV and 17 for children's; 17 is a cautious pick for phones
def to_seconds(ts):
secs = 0.0
for p in str(ts).split(":"):
secs = secs * 60 + float(p)
return secs
def srt_time(t):
ms = round(t * 1000)
h, ms = divmod(ms, 3600000)
m, ms = divmod(ms, 60000)
s, ms = divmod(ms, 1000)
return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
def split_text(text):
"""Wrap to MAX_CHARS per line; return a list of caption pages of at most MAX_LINES lines each."""
lines = textwrap.wrap(" ".join(text.split()), MAX_CHARS)
return ["\n".join(lines[i:i + MAX_LINES]) for i in range(0, len(lines), MAX_LINES)]
def build_cues(rows):
"""Split long lines into pages, share the time by length, enforce minimum duration without overlap."""
cues = []
for start, end, text in rows:
pages = split_text(text)
total = sum(len(p.replace("\n", " ")) for p in pages) or 1
t = start
for p in pages:
share = (end - start) * len(p.replace("\n", " ")) / total
cues.append([t, t + share, p])
t += share
for i, c in enumerate(cues):
c[1] = max(c[1], c[0] + MIN_SECONDS)
if i + 1 < len(cues):
c[1] = min(c[1], cues[i + 1][0]) # never overlap the next cue
return cues
def too_fast(cues):
"""Cues a viewer can't finish reading: more than CPS characters per second."""
return [c for c in cues if len(c[2].replace("\n", " ")) / (c[1] - c[0]) > CPS]
def to_srt(cues):
return "\n".join(f"{i}\n{srt_time(a)} --> {srt_time(b)}\n{t}\n" for i, (a, b, t) in enumerate(cues, 1))
def read_rows(path):
with open(path, newline="") as f:
return [(to_seconds(r["start"]), to_seconds(r["end"]), r["text"]) for r in csv.DictReader(f)]
# Sizes below are in libass's default 384x288 script space for SRT files, which is then scaled to the video: 1920 / 288
# is a factor of 6.67, so FontSize=11 is about 73 px tall and MarginV=50 lifts the text about 333 px off the bottom,
# clear of the part of the screen apps cover with buttons. original_size tells libass the real frame is 1080x1920 so
# the aspect ratio is right. (Passing pixel values such as MarginV=380 pushes the text off screen: I tried.)
STYLE = ("FontName=DejaVu Sans,Bold=1,FontSize=11,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,"
"BorderStyle=1,Outline=1,Shadow=0,Alignment=2,MarginV=50")
def burn(src, srt, dst):
subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", src,
"-vf", f"subtitles={srt}:original_size=1080x1920:force_style='{STYLE}'",
"-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "copy", dst], check=True)
if __name__ == "__main__":
if sys.argv[1] == "--burn":
burn(*sys.argv[2:5])
else:
cues = build_cues(read_rows(sys.argv[1]))
open(sys.argv[2], "w").write(to_srt(cues))
for c in too_fast(cues):
print(f"warning: {c[0]:.1f}s caption is too fast to read comfortably: {c[2]!r}")
The sample input uses invented narration to exercise the code:
lines.csv
start,end,text
0.0,4.5,In 1805 the fleet left port with no clear plan for the weather ahead.
4.5,7.0,Nobody aboard had seen this coast.
7.0,7.6,Then the wind changed and we turned.
Running it prints a warning for exactly one caption: the last line, which tries to fit 36 characters into 0.6 seconds. That is what I want from a check like this. The fix is editorial, not technical: shorten the line, or give it more time.
A bug I hit, so you don't have to
My first version rendered a perfectly valid video with no captions at all. The cause was a subtle one. When ffmpeg's subtitles filter loads an SRT file, it lays the text out on a small default canvas of 384 by 288 units and then scales it. I had written the style in pixels, with a bottom margin of 380, which is bigger than the whole 288-unit canvas, so the text was placed off the screen and nothing showed. The fix was to write the style in that canvas space, where a font size of 11 comes out around 73 pixels tall on a 1920-pixel-high video, and to tell libass the real frame size. Always look at the output, not just the exit code.
Does it work?
The tests check the logic and then render a real video. For the render, a 1080 by 1920 plain background gets the captions, and the test compares frames. At one second, the pixels that differ from the uncaptioned video are all in the lower middle of the frame, between 60% and 85% of the height. At nine seconds, after the last caption, no pixel differs. Six tests pass.
test_captions.py
import shutil
import subprocess
import tempfile
import unittest
from pathlib import Path
from captions import to_seconds, srt_time, split_text, build_cues, too_fast, to_srt, read_rows, burn, MAX_CHARS
HERE = Path(__file__).parent
class Basics(unittest.TestCase):
def test_time_formats(self):
self.assertEqual(to_seconds("1:02.5"), 62.5)
self.assertEqual(srt_time(3723.456), "01:02:03,456")
def test_lines_never_exceed_limit(self):
for page in split_text("In 1805 the fleet left port with no clear plan for the weather ahead and nobody knew the coast"):
for line in page.split("\n"):
self.assertLessEqual(len(line), MAX_CHARS)
self.assertLessEqual(page.count("\n"), 1)
def test_long_line_becomes_several_pages_in_order(self):
cues = build_cues([(0, 9, "word " * 30)])
self.assertGreater(len(cues), 1)
for a, b in zip(cues, cues[1:]):
self.assertLessEqual(a[1], b[0] + 1e-9) # no overlap
self.assertEqual(a[1], b[0])
def test_min_duration_and_speed_warning(self):
cues = build_cues(read_rows(HERE / "lines.csv"))
# a cue lasts at least MIN_SECONDS unless the next cue starts sooner, in which case it ends exactly there
for c, nxt in zip(cues, cues[1:] + [None]):
self.assertTrue(c[1] - c[0] >= 1.0 - 1e-9 or (nxt and c[1] == nxt[0]))
fast = too_fast(cues)
self.assertEqual(len(fast), 1) # only the 0.6 s line is crammed
self.assertIn("wind changed", fast[0][2])
def test_srt_has_numbered_blocks(self):
srt = to_srt(build_cues(read_rows(HERE / "lines.csv")))
self.assertTrue(srt.startswith("1\n00:00:00,000 --> "))
@unittest.skipUnless(shutil.which("ffmpeg"), "ffmpeg not installed")
class Burn(unittest.TestCase):
def test_burned_video_differs_only_where_text_is(self):
tmp = Path(tempfile.mkdtemp())
src, srt, out = tmp / "in.mp4", tmp / "c.srt", tmp / "out.mp4"
subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-f", "lavfi", "-i", "color=c=0x203040:s=1080x1920:r=30",
"-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo", "-t", "10", "-pix_fmt", "yuv420p",
"-c:v", "libx264", "-c:a", "aac", str(src)], check=True)
srt.write_text(to_srt(build_cues(read_rows(HERE / "lines.csv"))))
burn(str(src), str(srt), str(out))
# raw grey frames at t=1s (a caption is showing) and t=9s (no caption)
def frame(path, t):
return subprocess.run(["ffmpeg", "-loglevel", "error", "-ss", str(t), "-i", str(path), "-frames:v", "1",
"-f", "rawvideo", "-pix_fmt", "gray", "-"], capture_output=True, check=True).stdout
w, h = 1080, 1920
a, b, plain = frame(out, 1.0), frame(out, 9.0), frame(src, 1.0)
changed_rows = {i // w for i in range(len(a)) if abs(a[i] - plain[i]) > 40}
self.assertTrue(changed_rows, "no caption pixels found at 1s")
self.assertGreater(min(changed_rows), h * 0.60) # nothing drawn in the top 60%
self.assertLess(max(changed_rows), h * 0.85) # and clear of the bottom 15%
self.assertEqual(sum(1 for i in range(len(b)) if abs(b[i] - plain[i]) > 40), 0) # no caption at 9s
shutil.rmtree(tmp, ignore_errors=True)
if __name__ == "__main__":
unittest.main()
I also looked at the frame itself: two lines of bold white text with a black outline, centred, in the lower third. The tests don't judge taste, but they do prove the text lands where I said it would and goes away when it should.
Burned-in or separate caption files?
Burned-in captions (also called open captions) are part of the picture, so they show everywhere and can't be turned off. A separate SRT file lets a platform show captions as a track the viewer controls, and is easier to correct later. For short vertical clips on social feeds I burn them in, because the feed won't always show a track. For a longer video on a platform that accepts caption files, upload the SRT too. Keep the SRT either way, since you can reuse it for translation.
What Pixasocial says about captions
Pixasocial's homepage says it can detect, transcribe and translate captions in 60 languages in one pass. Its pricing page lists captions on video and stills, with several restyle options before you post, including named looks such as TikTok, Classic, Black bar, Comic and Pink glow. If you publish in several languages, that is the part that could save real time. I have not tested the accuracy of its transcripts or translations, and I'd treat them as I treat any automatic transcript: a first draft that a person must check, especially for names, places, dates and any language I can't read myself.
What I haven't verified
- Pixasocial's transcription and translation accuracy, or whether its caption styles meet the readability rules above.
- The overlay areas of the current Facebook, Instagram, TikTok and YouTube apps.
- That 17 characters per second suits your audience. It is a cautious borrowed figure, not a finding of mine.
I have not used Pixasocial for this post. Everything I say about it comes from its public pages, read on 17 November 2026. I haven't tested its publishing, captions, clip cutting or whether a Facebook Page can be connected. Its comparisons with Buffer, Hootsuite and Canva are the vendor's own and I haven't checked them. This post contains an affiliate link.
Want to see Pixasocial yourself?
If you caption in more than one language and want to see what Pixasocial's caption and posting tools include, you can look at the current product and pricing. This is an affiliate link: RAJIBS may earn a commission if you subscribe, at no extra cost to you. Check every automatic caption yourself before you publish.
Look at PixasocialWhat I ran this against
- ffmpeg 7.1.5 and ffprobe on Linux, Python 3.13.5, run on 17 November 2026. 6 tests pass. They check line wrapping, no-overlap timing, the reading-speed warning, SRT formatting and a real burn-in: the test renders a 1080x1920 video with captions, compares frames and checks that caption pixels appear only in the lower middle of the frame (between 60% and 85% of the height) and not at all after the last caption ends.
- I looked at a frame of the rendered result by eye. The font is DejaVu Sans Bold, which happened to be installed on my machine; yours may differ.
- I did not test any commercial caption tool or auto-transcription. The sample lines are invented placeholder narration, not facts.
- I did not check how any social app's own interface overlays your video, so placement is a starting point to check on a phone.
Sources checked
- FFmpeg documentation, filters (
boxblur,overlay,crop,scale,subtitles): ffmpeg.org/ffmpeg-filters.html. - Netflix Partner Help Center, "English (USA) Timed Text Style Guide" (42 characters per line, a maximum of two lines, up to 20 characters per second for adult programs and 17 for children's; dates and decades such as "1950s"): partnerhelp.netflixstudios.com, read 17 November 2026. It is written for TV, so I adapt the numbers for a narrow phone frame.
- Pixasocial homepage and pricing page, read 17 November 2026: pixasocial.com says it detects, transcribes and translates captions in 60 languages; the pricing page (app.pixasocial.com/pricing) lists captions on video and stills with restyle options such as TikTok, Classic, Black bar, Comic and Pink glow.