How to Add Captions to a TikTok Video

What people mean by TikTok captions · Prerequisites and versions · Pick a route: in-app, CapCut or script · Frame by frame: auto captions inside TikTok · Frame by frame: captions in CapCut · Caption style, timing and lower-third placement · Frame by frame: set up the caption kit · Frame by frame: chunk the transcript into cues · Frame by frame: lint, burn in and upload · Render settings and output examples · Common pitfalls · Troubleshooting · Write the post caption that sits under the video · Advanced tips · Before you render
The fastest way to add captions to a TikTok video is the built-in auto captioner. Open the editor, tap Captions, pick the spoken language, fix the words it misheard, style the text, and post. Plan on a few minutes for a clip that is under a minute long.
Three routes get you there, and this tutorial covers all of them: TikTok’s own tool, CapCut, and a small Python and ffmpeg project that turns a transcript into short, timed caption cues you control frame by frame. You will finish with a working caption kit, seventeen numbered steps, seven common pitfalls and eleven fixes for the errors people hit most. The search term “tiktok captions” also pulls people who want ideas for the text under a video, so the post-caption section near the end covers that too.
If you are still choosing a tool, our comparison of auto captions in five video editors shows how the editors differ on price and accuracy. Come back here when you need the actual buttons, settings and timing numbers.
What people mean by TikTok captions
Two different things share the name. On-screen captions are words timed to the speech and drawn over the picture, so a viewer who scrolls with the sound off still follows you. The post caption is the text under the video, which carries your hook, your keywords and your hashtags. Most of this guide covers the first kind. The second gets its own section near the end.
On-screen captions also split into open and closed. Open captions are burned into the pixels. Every viewer sees them, nobody can switch them off, and you decide the font, color and position. Closed captions travel as a separate text track that a viewer can toggle. Anything you style yourself in an editor behaves like open captions in practice, so plan the layout the way you would plan a lower third: the text must sit where the app’s own interface does not cover it.
Three reasons justify the work of adding TikTok captions to every video. Many people watch with the sound off, whether on a train, in a shared room or in a meeting they should not be scrolling in. Captions help viewers who are deaf or hard of hearing, and they help anyone listening in a second language. And speech recognition makes mistakes on names, brands and jargon, so a reviewed caption track protects your reputation as well as your reach.
Auto captions are a draft, never a finished product. The recognizer hears audio, not intent. It will turn a product name into a common word, drop a punctuation mark that changes a meaning, and split a sentence in an awkward place. Every route below includes a review pass for that reason. Skip the pass and you will ship the errors.
One more point about scope. This article is about the video track, so it stays on caption text, timing and placement. File size and platform limits live in other guides, and the exact upload caps change often enough that you should read the current figures before you export. Check them in the app on the day you post.
Prerequisites and versions
You need a vertical clip with clear speech. A clip with music only will not produce captions, because the recognizer has nothing to transcribe. Record or export in 9:16 so the captions you place on screen match the frame TikTok shows. If your clip starts as a landscape file, reframe it first and caption second, because moving the picture after the captions are placed shifts everything.

For the in-app route you need the TikTok app on a recent release from the App Store or Google Play. Button labels and menu positions have moved between releases, so if a label in this guide does not match your screen, look for the same icon or the nearest equivalent. For the CapCut route you need the current CapCut on mobile or desktop. For the script route you need a computer with Python, ffmpeg and a speech-to-text package.
The table lists what each part of the project needs. Where a version is not pinned, install the current stable release, because the project does not depend on anything exotic.
| Component | Version or requirement | Used for | Cost |
|---|---|---|---|
| TikTok app | Current release from your app store | Built-in auto captions, posting | Free to install |
| CapCut | Current mobile or desktop release | Editable captions with style presets | Free tier, paid tiers exist |
| Python | 3.10 or newer | Chunker and lint scripts | Free, open source |
| ffmpeg | Current stable build with libass | Burning captions into the video | Free, open source |
| openai-whisper | Current release from pip | Word-level timestamps from speech | Free, open source |
| Source clip | 9:16, clean speech, final edit locked | Everything above | Your own footage |
| Installed font | A bold sans serif you have the licence for | Readable burned-in text | Varies |
Check the ffmpeg build before you start. Run ffmpeg -filters and look for the ass and subtitles filters. Some minimal builds ship without libass, and the burn-in step fails with a confusing error if the filter is missing. The troubleshooting list covers that case.
CapCut’s own pages describe a Free tier and paid tiers, and they list Free, Pro, Ultra and Teams plans. CapCut’s help pages also say that watermark-free export depends on which features and which app version you use, and that some templates add an ending logo clip. Read the current pricing page before you commit a client project to any feature, because plan details and promotions have shifted through 2026.
Pick a route: in-app, CapCut or script
Use the in-app captioner when speed matters and the clip is short. Use CapCut when you want a saved style, finer control over cue timing, or a desktop timeline. Use the script when you caption many clips, want the same look every time, or need the caption file as a separate asset you can translate, lint and archive.
| Route | Best for | Control over cue timing | Repeatable look | Output |
|---|---|---|---|---|
| TikTok built-in | One-off posts, fast turnaround | Edit text, limited timing control | Style chosen per video | Posted inside TikTok |
| CapCut | Creators who edit on phone or desktop | Split, merge and nudge each cue | Saved preset, applied in one tap | Exported MP4 |
| Python and ffmpeg | Series, batches, client work | Full control, cues in a text file | Same style file every run | SRT, ASS and burned MP4 |
The routes can combine. A common pattern is to generate captions in CapCut, export the video with the text burned in, and turn TikTok’s own auto captions off for that post so viewers do not see two sets. Another pattern is to run the script for the cue timing, import the SRT into an editor, and style the text there. Whatever you pick, make one route the owner of the captions in each video. Two owners produce duplicates.
Think about what you will do after the post goes live. Captions made inside TikTok stay inside TikTok, so a caption error found a day later means editing in the app or reposting. Burned-in captions from CapCut or the script become part of the file, so a fix means a new export and a new upload. If you expect to revise a lot, keep the SRT, because it takes seconds to regenerate the burned file from a corrected text.
Cost matters less than people expect for short clips. We found no separate price listed for TikTok’s built-in tool, and the script route uses free open-source tools. CapCut is where plan limits show up, so test your export on the free tier before you build a workflow around it.
Frame by frame: auto captions inside TikTok
This route takes six steps. The wording of the buttons may differ slightly on your phone, so follow the icons and the order rather than the exact label.
Steps 1 to 3: cut, open Captions, generate
Step 1. Lock the edit before you caption. Trim the dead air at the start and end, add your music, and fix the audio levels. Captions are timed to the audio you have at the moment you generate them. If you trim the clip afterwards, the cues can drift out of sync. Do the final cut first and caption last.
Step 2. Open the editor and find Captions. Record or upload the clip and go to the edit screen. Look along the right-hand toolbar for a Captions option. On smaller screens the toolbar collapses, so tap the arrow or the more icon to reveal the hidden tools. If you cannot find the option, update the app and check that the clip contains speech.
Step 3. Set the spoken language and generate. The recognizer needs to know which language it is hearing. Pick the language you speak in the clip, not the language of your audience, and let the tool process the audio. A short clip usually finishes in seconds. When the captions appear on screen, pause on the first cue and confirm the timing lines up with your mouth.
Steps 4 to 6: correct, style, preview and post
Step 4. Correct every cue. Open the caption editor and read the whole transcript, not just the first line. Fix names, brand spellings, product terms, numbers and punctuation. Pay attention to words that sound alike, such as “there” and “their” or a brand that resembles a common word. Check that each cue still reads as a complete thought. If a cue ends mid-phrase, merge or split it where the editor allows.
Step 5. Style and place the text. Choose a bold, plain font, a high-contrast color and an outline or background that holds up over both light and dark footage. Then place the block. The bottom strip of the screen is crowded with the account name, the description and the buttons, so lift captions into the lower middle of the frame, above that strip and clear of faces. Leave a margin on the left and right so no line touches the edge.
Step 6. Preview muted and post. Play the clip with the volume off and read it as a stranger would. If you stumble on a line, viewers will too. Then write the post caption and publish. After posting, open the live video once on your own account and check that the captions sit where you intended on a different phone size if you have one.
A short reminder on timing language. Each cue has an in point, a hold and an out point. The in point should land on the first syllable or a few frames before it. The hold should last long enough to read the words at a normal pace. The out point should leave a small gap before the next cue, so the text refreshes visibly instead of smearing together.
Frame by frame: captions in CapCut
CapCut gives you a timeline, a saved style and per-cue control that the in-app tool does not offer. The steps below work on mobile and desktop, with small differences in where the panels live. CapCut’s official pages describe caption and transcript tools as part of its editing and AI workflow, so look under the text or captions panel in your version.
Steps 7 to 9: import, generate, fix
Step 7. Import the clip and set the canvas to 9:16. Start a new project, add the final cut of your video, and set the ratio to vertical. Confirm the canvas matches the clip so nothing is cropped when you export. Do not start from a template unless you want its look. If you do use one, such as the NEW CINEMATIC template page on CapCut, delete its placeholder text before you generate captions.
Step 8. Generate captions from the speech. Open the text or captions panel and choose the auto caption option. Select the spoken language and run it. CapCut places a track of cues under the video. Some captioning features sit behind a paid tier in some versions, so if the button is locked, check the plan note on the screen before you assume something is broken.
Step 9. Fix the cues one by one. Select each cue and correct the text. Split long cues at a natural pause and merge short ones that read as a single phrase. Use the timeline to nudge the in point so the caption appears with the first word. Keep each cue to a few words and a single line where you can. Then play the whole clip in a loop with the sound off.
Steps 10 and 11: style once, export, avoid doubles
Step 10. Style one cue, then apply that style to all. Set the font, size, color, outline and position on the first cue. Save it as a preset if your version offers that, or use the option that applies the current style to every caption in the track. This is the single biggest time saver in CapCut, because it gives every cue the same look in one action.
Step 11. Export, then post with TikTok’s own captions off. Export at the vertical resolution your source has and check the preview for any watermark or ending logo clip. CapCut’s help pages say watermark-free export depends on the features and app version in use, and that templates may add an ending clip, so test one export before the real post. Upload the file to TikTok and skip the in-app auto captions, since yours are already burned in.
If you hit a locked feature, a free-tier watermark or an unexpected ending clip, remove the template or the premium asset that caused it and export again. CapCut’s help page for March 2026 says Pro unlocks premium assets without that path, which tells you the paid tier is aimed at exactly this problem.
Caption style, timing and lower-third placement
Good TikTok captions follow the same rules as good lower thirds: legible against any background, placed outside the zone the interface covers, and on screen long enough to read. The numbers below are working guidelines from caption practice, not TikTok limits. Adjust them after you preview on a real phone.
- Cue length. Keep a cue to about three to six words and one or two short lines. Longer cues make the viewer read instead of watch.
- Hold time. Leave a cue up for at least a second unless the speaker really talks that fast. A cue under about 0.7 seconds is hard to read.
- Phrase breaks. End a cue at a comma, a full stop or a natural pause. Never end on a word like “the” or “with”, because the next cue then starts mid-thought.
- Position. Sit the text in the lower middle of the frame, lifted above the account name, the description and the button column. A burned-in block that sits too low gets covered.
- Contrast. Use white or a bright color with a dark outline, or a semi-transparent box behind the text. Test over your brightest scene.
- Case and font. Pick one bold sans serif. All caps works for short punchy cues but tires the eye on longer ones, so reserve it for hooks.
- Emphasis. Color one key word per cue at most. Highlighting every word turns emphasis into noise.
Think of three presets. A clean talking-head style uses sentence case, white text, a thin outline and cues of four or five words. A bold hook style uses larger text and all caps for the first few seconds, then drops back to the clean style. An explainer style adds a small speaker lower third at the start, with a name and role that holds for a few seconds, then hands over to the caption track. Keep the lower third and the captions in separate zones so they never collide.
Where the caption sits changes with the video. If the speaker’s face fills the upper half, put captions in the lower middle. If you have a product on a table at the bottom of the frame, move the captions up and check that they do not hide the product. If you use burned-in lower thirds for names, see our guide to lower thirds and titles for the placement and timing rules that apply to them as well.
Finally, keep the style consistent across a series. A viewer who sees your captions three times starts to recognize the look, and that recognition is a small branding win that costs nothing.
Frame by frame: set up the caption kit
The script route uses three small tools. Whisper turns speech into text with a timestamp for every word. A Python script groups those words into short cues and writes an SRT file and a styled ASS file. ffmpeg burns the ASS file into the video. You can run the whole thing from one shell script.
Step 12: install the tools
Create a project folder and install the packages. The commands assume Python and ffmpeg are already on your path.
caption-kit/
clips/
demo.mp4 your final, locked 9:16 edit
build/ generated JSON, SRT, ASS and MP4 land here
chunk_captions.py words to cues (SRT + ASS)
lint_srt.py cue checker
build.sh runs the whole pipeline
mkdir caption-kit
cd caption-kit
python3 -m venv .venv
source .venv/bin/activate
pip install -U openai-whisper
ffmpeg -hide_banner -filters | grep -E " (ass|subtitles) "
Whisper downloads its model the first time you run it, so the first transcription takes longer than the ones after it. A graphics card speeds the work up, but a plain laptop handles a short vertical clip without trouble. Keep the clip name short and free of spaces, since that name flows into every file the pipeline writes. A name like demo.mp4 becomes demo.json, demo.srt, demo.ass and demo_captioned.mp4, and you will be glad of the tidy trail when you run ten clips in a row.
Confirm ffmpeg has the libass filters. If the second command prints nothing, install a fuller ffmpeg build before you continue.
Step 13: transcribe with word timestamps
Run Whisper on your clip and ask for word-level timestamps. Without them, the chunker has no timing to work with. The small model is a sensible default on a laptop, and a larger model improves accuracy at the cost of time. If your clip includes brand names or jargon, pass them in an initial prompt so the model leans toward those spellings.
whisper clips/demo.mp4 --model small --language en --word_timestamps True \
--output_format json --output_dir build \
--initial_prompt "TikTok, CapCut, Whisper, ffmpeg"
The JSON file lands in the build folder with the clip’s name. Open it and confirm each segment has a words list. If it does not, the flag was missing and the chunker will stop with a clear message.
Two notes on this step. First, transcribe the audio of your final edit, not an earlier cut. Second, keep the JSON. It is the source of truth for timing, and you can re-chunk it with different settings in a second without running Whisper again.
Frame by frame: chunk the transcript into cues
Raw Whisper segments are sentences, and sentences make poor TikTok captions. The chunker splits the word stream into short cues using four rules. It starts a new cue when it reaches a word or character limit, when a sentence ends, when a comma falls near the end of a cue, and when the speaker pauses for longer than the gap setting. It also pulls dangling words like “the” and “with” over to the start of the next cue, so a cue never ends mid-phrase.

Step 14: save the chunker
Save the script below as chunk_captions.py. It reads the JSON, builds the cues, enforces a minimum on-screen time, trims overlaps, and writes both an SRT and an ASS file. The ASS file carries the style, so position, font and outline live in one place.
#!/usr/bin/env python3
"""Turn a Whisper word-timestamp JSON into short TikTok-style caption chunks (SRT + ASS)."""
import argparse
import json
import sys
END_MARKS = (".", "?", "!")
SOFT_MARKS = (",", ";", ":")
DANGLERS = {"a", "an", "the", "and", "or", "but", "to", "of", "with", "in", "on", "for", "at", "is", "your", "my"}
def load_words(path):
with open(path, encoding="utf-8") as f:
data = json.load(f)
words = []
for seg in data["segments"]:
for w in seg.get("words", []):
text = w["word"].strip()
if text:
words.append({"text": text, "start": float(w["start"]), "end": float(w["end"])})
if not words:
sys.exit("No word timestamps found. Run whisper with --word_timestamps True.")
return words
def build_chunks(words, max_words, max_chars, max_gap, min_dur):
chunks, cur = [], []
def flush(carry=0):
keep = []
while carry and len(cur) > 1:
keep.insert(0, cur.pop())
carry -= 1
if cur:
chunks.append({"text": " ".join(w["text"] for w in cur),
"start": cur[0]["start"], "end": cur[-1]["end"]})
cur.clear()
cur.extend(keep)
for i, w in enumerate(words):
if cur and w["start"] - cur[-1]["end"] > max_gap:
flush()
cur.append(w)
joined = " ".join(x["text"] for x in cur)
last = i == len(words) - 1
too_long = len(cur) >= max_words or len(joined) >= max_chars
hard_stop = w["text"].endswith(END_MARKS)
soft_stop = w["text"].endswith(SOFT_MARKS) and len(cur) >= max(2, max_words - 2)
if last or hard_stop:
flush()
elif too_long or soft_stop:
carry = 0
while carry < len(cur) - 1 and cur[-1 - carry]["text"].lower().strip(".,!?") in DANGLERS:
carry += 1
flush(carry)
for i, c in enumerate(chunks):
if c["end"] - c["start"] < min_dur:
c["end"] = c["start"] + min_dur
if i + 1 < len(chunks) and c["end"] > chunks[i + 1]["start"]:
c["end"] = chunks[i + 1]["start"]
return chunks
def stamp_srt(t):
ms = int(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 stamp_ass(t):
cs = int(round(t * 100))
h, cs = divmod(cs, 360000)
m, cs = divmod(cs, 6000)
s, cs = divmod(cs, 100)
return f"{h}:{m:02d}:{s:02d}.{cs:02d}"
def write_srt(chunks, path):
with open(path, "w", encoding="utf-8") as f:
for n, c in enumerate(chunks, 1):
f.write(f"{n}\n{stamp_srt(c['start'])} --> {stamp_srt(c['end'])}\n{c['text']}\n\n")
def write_ass(chunks, path, width, height, font, size, margin_v, upper):
head = (
"[Script Info]\nScriptType: v4.00+\n"
f"PlayResX: {width}\nPlayResY: {height}\nWrapStyle: 0\n\n"
"[V4+ Styles]\n"
"Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, "
"Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, "
"Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n"
f"Style: Cap,{font},{size},&H00FFFFFF,&H000000FF,&H00000000,&H64000000,"
f"-1,0,0,0,100,100,0,0,1,6,2,2,90,90,{margin_v},1\n\n"
"[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n"
)
with open(path, "w", encoding="utf-8") as f:
f.write(head)
for c in chunks:
text = c["text"].upper() if upper else c["text"]
f.write(f"Dialogue: 0,{stamp_ass(c['start'])},{stamp_ass(c['end'])},Cap,,0,0,0,,{text}\n")
def report(chunks, max_words):
problems = 0
for n, c in enumerate(chunks, 1):
dur = c["end"] - c["start"]
count = len(c["text"].split())
if count > max_words or dur < 0.7:
problems += 1
print(f" check #{n}: {count} words, {dur:.2f}s -> {c['text']}")
print(f"{len(chunks)} chunks, {problems} flagged")
def main():
p = argparse.ArgumentParser()
p.add_argument("json_file")
p.add_argument("--out", default="captions")
p.add_argument("--max-words", type=int, default=5)
p.add_argument("--max-chars", type=int, default=28)
p.add_argument("--max-gap", type=float, default=0.6)
p.add_argument("--min-dur", type=float, default=0.8)
p.add_argument("--width", type=int, default=1080)
p.add_argument("--height", type=int, default=1920)
p.add_argument("--font", default="Arial")
p.add_argument("--size", type=int, default=84)
p.add_argument("--margin-v", type=int, default=520)
p.add_argument("--upper", action="store_true")
a = p.parse_args()
chunks = build_chunks(load_words(a.json_file), a.max_words, a.max_chars, a.max_gap, a.min_dur)
write_srt(chunks, a.out + ".srt")
write_ass(chunks, a.out + ".ass", a.width, a.height, a.font, a.size, a.margin_v, a.upper)
report(chunks, a.max_words)
if __name__ == "__main__":
main()
Run it on your transcript and check the result on a phone. Caption size, line length and how far the text sits from the bottom edge are your call, and TikTok does not set a fixed rule for them. Adjust the margin until the captions stay clear of the interface and read comfortably.
python3 chunk_captions.py build/demo.json --out build/demo --max-words 5 --size 84 --margin-v 520
The --upper flag switches to all caps for a hook-style look. The --max-words flag controls cue length, and --max-gap sets how long a pause must be before a new cue starts. Change one setting at a time so you can see what each one does.
Tune the settings to the speaker. A fast talker needs a lower word limit and a shorter character limit, so cues turn over more often and each one stays readable. A slow, deliberate speaker can carry longer cues, and a bigger gap setting stops the chunker from splitting every breath. If a cue always looks cramped, lower the font size by a few points before you touch the word limit. If the text sits too close to the account name on your phone, raise the bottom margin in steps and preview each change.
Why write the ASS file instead of only the SRT? SRT stores text and timing but no styling beyond a few tags, and each player interprets it differently. ASS stores the style with the cues, which makes the burned-in result predictable from one run to the next. You still get the SRT for editors, translators and archives.
Frame by frame: lint, burn in and upload
Before you burn anything into the picture, lint the cues. A burned-in mistake means a new render. The lint script reads the SRT and flags cues with too many words, too little screen time, too many characters per second and overlaps with the previous cue.
Step 15: lint the cues and fix by hand
Save the script as lint_srt.py. Its thresholds are working defaults: six words, 0.7 seconds and 20 characters per second. Loosen or tighten them to suit your speaker.
#!/usr/bin/env python3
"""Flag caption cues that are too long, too short, too fast or overlapping."""
import re
import sys
TIME = re.compile(r"(\d+):(\d+):(\d+),(\d+) --> (\d+):(\d+):(\d+),(\d+)")
def secs(h, m, s, ms):
return int(h) * 3600 + int(m) * 60 + int(s) + int(ms) / 1000
def main(path, max_words=6, min_dur=0.7, max_cps=20):
blocks = open(path, encoding="utf-8").read().strip().split("\n\n")
prev_end, issues = 0.0, 0
for block in blocks:
lines = block.splitlines()
m = TIME.match(lines[1])
start, end = secs(*m.groups()[:4]), secs(*m.groups()[4:])
text = " ".join(lines[2:])
dur = end - start
notes = []
if len(text.split()) > max_words:
notes.append("too many words")
if dur < min_dur:
notes.append("on screen under %.1fs" % min_dur)
if len(text) / dur > max_cps:
notes.append("%.0f chars per second" % (len(text) / dur))
if start < prev_end:
notes.append("overlaps the cue before it")
prev_end = end
if notes:
issues += 1
print("cue %s: %s -> %s" % (lines[0], ", ".join(notes), text))
print("%d cues, %d with issues" % (len(blocks), issues))
return 1 if issues else 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1]))
When the linter flags a cue, open the SRT in a text editor and fix it. Merge two short cues, split a long one, or nudge a time stamp. Then run the linter again. Keep going until it reports zero issues. The thresholds act as tripwires, so a flag does not always mean a cue is wrong. A one-word cue like “Wait.” can run under the minimum time on purpose, and you can leave it. The point is that you decide, rather than discovering the problem after the render. If you want a different wording, edit the ASS file too, or regenerate it from a corrected JSON.
Step 16: burn in the captions
The build script below ties the steps together. It transcribes, chunks and burns in with one command, and it writes the outputs to the build folder. The lint step exits with an error when it finds a problem, which stops the build before ffmpeg runs. The ffmpeg command re-encodes the video with H.264 at a high quality setting, keeps the pixel format that phones expect, and moves the index to the front of the file so playback can start quickly.
#!/usr/bin/env bash
set -euo pipefail
IN="${1:?usage: ./build.sh clips/name.mp4}"
BASE="$(basename "${IN%.*}")"
mkdir -p build
whisper "$IN" --model small --language en --word_timestamps True \
--output_format json --output_dir build
python3 chunk_captions.py "build/$BASE.json" --out "build/$BASE"
python3 lint_srt.py "build/$BASE.srt"
ffmpeg -y -i "$IN" -vf "ass=build/$BASE.ass" \
-c:v libx264 -crf 18 -preset medium -pix_fmt yuv420p \
-c:a aac -b:a 192k -movflags +faststart "build/${BASE}_captioned.mp4"
Step 17: check the file and upload
Run a quick probe on the output. You want 1080 by 1920, your original frame rate and an audio stream.
ffprobe -v error -select_streams v:0 \
-show_entries stream=codec_name,width,height,r_frame_rate \
-of default=nw=1 build/demo_captioned.mp4
Then scrub the file with the sound off, read every cue, and upload it to TikTok with the in-app auto captions switched off. Keep the SRT next to the video in your project folder. When you reuse the clip in a different language, a translated SRT becomes a copy-paste job.
Render settings and output examples
Use the table as a starting point for any burned-in caption export. The values are production choices, not platform requirements, so read the current upload limits in the app before you post.
| Setting | Value | Why |
|---|---|---|
| Resolution | 1080 x 1920 (9:16) | Matches the vertical frame TikTok displays |
| Frame rate | Same as the source clip | Avoids retiming that blurs motion and shifts cues |
| Video codec | H.264 (libx264), CRF 18 | Plays everywhere, keeps text edges crisp |
| Audio | AAC, 192 kbps | Clean speech survives TikTok’s re-encode |
| Pixel format | yuv420p | Required for broad phone compatibility |
| Container | MP4 with faststart | Quick start of playback after upload |
| Caption length | 3 to 6 words per cue | Readable at a glance |
Here is what the pipeline prints and produces on the sample transcript that ships with the project. The first block is the chunker’s summary line, followed by the SRT it wrote. The sample sentence reads “Most TikTok viewers scroll with the sound off. So add captions, check every line, and keep them short.”
5 chunks, 0 flagged
1
00:00:00,200 --> 00:00:01,550
Most TikTok viewers scroll
2
00:00:01,550 --> 00:00:02,600
with the sound off.
3
00:00:03,400 --> 00:00:04,400
So add captions,
4
00:00:04,450 --> 00:00:05,450
check every line,
5
00:00:05,500 --> 00:00:06,700
and keep them short.
The lint script prints a clean result for that file. Run it on a deliberately bad file and it names each problem so you know where to look.
$ python3 lint_srt.py demo.srt
5 cues, 0 with issues
$ python3 lint_srt.py bad.srt
cue 1: too many words, on screen under 0.7s, 114 chars per second -> This line has far too many words to read in half a second
cue 2: overlaps the cue before it -> ok
2 cues, 2 with issues
Check the output against the picture as well as the numbers. A cue that passes the linter can still read badly over a busy background, so scrub the finished file at normal speed. Test on two phones if you can, one with a small screen and one with a large screen, because the safe zone shifts with the aspect of the display. File size stays modest at this quality setting for a short vertical clip, and TikTok re-encodes the upload anyway, so do not chase a smaller file at the cost of soft text edges.
Notice how the chunker moved “with the” to the start of the second cue. That is the dangling-word rule at work. Without it, the first cue would have ended on “with”, and the viewer would read half a thought before the screen changes.
Common pitfalls
These seven mistakes cause most of the unreadable captions on short vertical video.
- Trusting the first draft. Auto captions are a draft. Names, brands and numbers go wrong most often. Read every cue and fix the text before you style anything.
- Captions under the interface. TikTok overlays the account name, description and action buttons on the lower part of the frame. Text parked in that strip disappears. Lift it into the lower middle and preview on a phone.
- Two sets of captions. Burn captions into the file and leave the in-app auto captions on, and viewers see both. Pick one owner for each video.
- Cues that are too long or too fast. A cue of ten words that sits on screen for a second forces the viewer to read faster than they can. Split long cues and hold each for at least a second.
- Captioning before the final cut. Trimming or retiming after you generate captions shifts the audio against the text. Lock the edit, then caption.
- Weak contrast. White text on a bright shirt or a snowy scene vanishes. Use an outline or a box, and test against your brightest frame.
- A missing font. When ffmpeg cannot find the font named in the ASS file, it substitutes another, and your layout breaks. Install the font or point ffmpeg at a font folder.
Most of these come from rushing the review. Give the caption pass its own slot in your edit: one read for wording, one for timing with the sound off, one for placement on a real phone. Three short passes catch more than one long one, because each pass looks for a single kind of error.
A related trap is changing the aspect ratio after the fact. If you caption a landscape clip and then crop to vertical, the text can fall outside the crop. Reframe first, then caption.
Troubleshooting
Each item below names the symptom and the fix. Work through them in order when something looks wrong.
- The Captions option is missing in TikTok. Update the app, expand the collapsed toolbar and check that your clip actually contains speech. If it still does not appear, caption in CapCut or with the script and upload the burned-in file.
- The captions come out in the wrong language. The recognizer used the wrong language setting. Set the spoken language before you generate, then regenerate.
- Names and brands are wrong. Edit them by hand in the caption editor. In the script route, pass the spellings to Whisper with the
--initial_promptoption and run the transcription again. - Cues drift out of sync after a trim. The captions were generated against an earlier cut. Delete them and generate again on the final edit.
- ffmpeg says “No such filter: ‘ass'”. Your ffmpeg build lacks libass. Install a full build, then check again with
ffmpeg -filters. - The burned-in font looks wrong. The font named in the ASS style is not installed. Install it, or place the font file in a folder and add
:fontsdir=fontsto the ass filter. - The chunker says no word timestamps were found. You ran Whisper without
--word_timestamps True. Run it again with the flag. - The ass filter fails on a path with spaces or a drive letter. Run ffmpeg from the folder that holds the file and use a short relative path, or rename the folder to avoid special characters.
- The CapCut export has a watermark or an ending clip. A template or a premium asset triggered it. Remove that element or check the plan, and export a test before the real run.
- The text looks soft after upload. TikTok re-encodes every upload. Export at full vertical resolution with a high quality setting and use a bold font with an outline so thin strokes do not blur.
- Lines touch the edge of the frame. The left and right margins are too small or the font is too large. Raise the side margins in the ASS style or lower the font size.
Write the post caption that sits under the video
Many people who search for tiktok captions want the text that goes below the video, not the on-screen words. That field does a different job. It gives the algorithm and the viewer context, it carries your hook, and it holds hashtags. It also has a character cap, which has changed over time, so trust the counter in the app over any number you read in a blog post.
Lead with the hook. Put the most important idea in the first line, because the description is truncated in the feed and only the opening shows until someone taps to expand. Say what the video gives the viewer. A line like “Three fixes for muddy audio” tells a stranger what to expect, and “wait for it” tells them nothing.
Use the words people search for. Many viewers search inside TikTok, so a description that says what the video is about in plain terms gives the video a better chance to surface for those terms. Name the topic, the tool or the problem. Avoid stuffing the field with a dozen near-identical phrases, which reads as spam.
Add a clear next step when you have one, such as a question that invites a comment or a pointer to a part two. Keep hashtags relevant and few. A short set that names the topic and the niche works better than a pile of generic tags. Place them at the end so they do not crowd the hook.
Match the caption to the on-screen text. If your burned-in captions say one thing and the description says another, you create friction. The on-screen words carry the content, and the description frames it. Treat them as a pair.
A few formulas that work for how-to content:
- Promise plus proof. “How I fixed echo in a spare room, before and after.”
- Question plus answer teaser. “Why does your voice sound thin on camera? The fix is in the last line.”
- List hook. “Three caption mistakes that hide your text.”
- Series tag. “Part 2 of the caption series. Part 1 covers auto captions.”
Write the description after you finish the on-screen captions, because by then you know exactly what the video says and where the key phrase lands.
Advanced tips
Once the basic kit works, a few additions make it more useful.
Highlight the word being spoken. ASS supports karaoke tags that color each word as it is spoken. Whisper already gives you per-word timing, so you can write one cue per chunk and wrap each word in a timing tag. Use it for hooks and short punchy clips and skip it for long explanations, where constant motion tires the eye.
Translate the SRT. Because the SRT is plain text, you can send it to a translator or a translation tool and drop the result back into the same pipeline. Check line lengths again after translating, since some languages run longer and your cues may overflow. Run the linter on every language file.
Add a speaker lower third. At the start of a clip, show the speaker’s name and role for a few seconds, then let the captions take over. Put the name in a separate ASS style with a different margin so the two never collide. For more on lower thirds and titles, see the guide linked earlier.
Batch a series. Wrap the build script in a loop over a folder of clips. Keep one style file for the whole series, and every video gets the same look with no manual work. Store the JSON next to each video so you can rebuild with new settings later.
Run a native-speaker check. For clips in a second language, ask a fluent speaker to read the SRT before you burn it in. Speech models handle some languages and accents better than others, and a human pass costs minutes.
Version the style. Treat the ASS style line as a brand asset. Save it with a name and a date, and note which series uses it. When you change fonts or colors, you will know exactly which videos need a re-render.
Guard against copy errors. Keep a short glossary file of your brand and product names and feed it to Whisper as the initial prompt on every run. It takes a minute to set up and removes the most common error in the transcript.
Before you render
How do I add captions to a TikTok video? Open the editor after recording or uploading, find Captions in the toolbar, pick the spoken language, let the tool generate the text, correct it and style it, then post. If the option is missing, caption in CapCut or with the script and upload the finished file.
Should I use TikTok’s captions or CapCut? Use TikTok’s tool for quick one-off posts. Use CapCut when you want saved styles and finer control over each cue. Whichever you choose, avoid stacking both on the same video.
How many words should a caption cue have? About three to six words on one or two short lines works for most speech. That is a working guideline, not a platform rule, so adjust it to your speaker’s pace.
Where should captions sit on a TikTok video? In the lower middle of the frame, above the strip where the account name, description and buttons appear, and clear of faces and products. Preview on a phone, because the interface changes between app versions.
Can I fix captions after I post? Captions burned into the file cannot change, so you would re-export and upload again. For text added inside the app, check what the current edit options allow. Keep the SRT so a corrected re-render takes seconds.
What is the difference between video captions and the post caption? Video captions are the words on screen that follow the speech. The post caption is the description under the video, where the hook, keywords and hashtags go.
Can I caption a video in another language? Yes. Generate the transcript in the spoken language, translate the SRT, and run the translated file through the same style and lint steps. Check the cue lengths again after translating.
- Logo Design upload a logo, get an animated logo intro
- Epic Smoky Titles your text in a smoke title sequence
- Star Text animated title theme
- All Vipid themes specs for every theme
Ines Calder
Ines Calder is the Titles & Motion Editor at Vipid, covering lower thirds, title sequences, kinetic typography and logo animation across After Effects, Premiere Pro, DaVinci Resolve and Final Cut Pro. She writes her guides in frames and safe areas so they hold up on a phone as well as a TV, and every template she lists carries its editor version, plugin needs and licence.
![Lower Thirds Examples [2026]: 6 Styles, 5 Editors](https://ivipid.com/blog/wp-content/uploads/2026/11/lower-thirds-examples-2026-gen-800x450.webp)
![Title Card Maker [2026]: 6 Tools, $0 to $299.99](https://ivipid.com/blog/wp-content/uploads/2026/11/title-card-maker-2026-gen-800x450.webp)
![End Credits Template [2026]: 6 Editors, $0 to $299.99](https://ivipid.com/blog/wp-content/uploads/2026/11/end-credits-template-2026-gen-800x450.webp)