Burn SRT Subtitles Into a Video With Rendi

The Short Answer

Burn the SRT when every viewer must see the same captions, regardless of what the player does with subtitle tracks. Keep the SRT separate when viewers need to switch captions off, change languages, or use player-level accessibility controls.

With Rendi, the working path is:

1. Check the final video and SRT together.
2. Put both files at URLs Rendi can fetch, or upload local files to Rendi first.
3. Submit the documented FFmpeg subtitle command.
4. Poll the command ID, or let a webhook receive the terminal result.
5. Inspect the MP4 metadata and watch the full output before sending more jobs.

That sequence matters. A successful encoder can still produce a bad deliverable if a caption is early, a name is wrong, or the text sits under a platform's interface.

What Rendi Is Doing

Rendi is the machine room, not the editor. You send it the same FFmpeg instruction you would run locally, but over an HTTP API. Think of the request as a work order: the input aliases tell the machine where the materials are, the FFmpeg string tells it what operation to perform, and the output alias names the finished part.

The current request schema requires an ffmpeg_command and output_files. Input keys start with in_, output keys start with out_, and those names reappear inside the command between double braces. A successful submission returns a command_id, which is the claim ticket for the job.

For the simplest path, the video and SRT sit at public or time-limited signed HTTP URLs whose filenames appear at the end. A local path on your laptop is not an input URL. Rendi also has a multipart direct-upload flow for local files, with support for files up to 5 TB, but that is a separate preparation step.

Burned Captions and Selectable Tracks Are Different Outputs

Burned captions become part of every decoded frame. That makes their appearance predictable, but it also makes the decision permanent. A spelling correction means another video render, and viewers cannot hide the captions.

A selectable subtitle track remains separate from the picture. Rendi's own subtitle example recommends mov_text for a soft subtitle track in MP4 and omits the video filter. That preserves viewer control and avoids baking the text into the image.

My rule is direct: use a burned review master or social delivery file when visual consistency is the requirement. Preserve the original SRT, and provide a selectable track or sidecar file wherever accessibility, search, translation, or viewer choice matters.

Check the SRT Before You Spend a Render

The cheapest render is the one you do not repeat. Review the SRT against the exact final cut, not an earlier export. Confirm the cue order, start and end times, spelling of names and numbers, intentional line breaks, and representative accented or non-Latin characters. Watch for captions that collide with lower-thirds or sit too close to the bottom edge.

Do not fold AI transcription into this step mentally. Speech recognition can draft an SRT upstream, but the file should reach this workflow only after a person or trusted review process has approved the words and timing. Rendi's job here is rendering.

Submit a Styled Rendi Job

This Node.js example uses Rendi's public sample video and sample SRT, so only RENDI_API_KEY is required to run it. The payload matches Rendi's live OpenAPI field names and alias rules. The force_style values create white text with a black outline and a bottom margin, while libx264 and AAC produce the MP4 described in Rendi's subtitle recipe.

const headers = {
  "X-API-KEY": process.env.RENDI_API_KEY,
  "Content-Type": "application/json",
};

const submit = await fetch("https://api.rendi.dev/v1/run-ffmpeg-command", {
  method: "POST",
  headers,
  body: JSON.stringify({
    input_files: {
      in_video: "https://storage.rendi.dev/sample/big_buck_bunny_720p_16sec.mp4",
      in_srt: "https://storage.rendi.dev/sample/subtitles.srt",
    },
    output_files: { out_1: "subtitled.mp4" },
    ffmpeg_command:
      "-i {{in_video}} -vf \"subtitles={{in_srt}}:force_style='FontSize=22,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,BorderStyle=1,Outline=2,Shadow=0,MarginV=36'\" -c:v libx264 -crf 20 -c:a aac -b:a 192k {{out_1}}",
  }),
});

if (!submit.ok) throw new Error(await submit.text());
const { command_id } = await submit.json();

for (;;) {
  const poll = await fetch(
    `https://api.rendi.dev/v1/commands/${command_id}`,
    { headers: { "X-API-KEY": process.env.RENDI_API_KEY } },
  );
  const job = await poll.json();
  if (job.status === "SUCCESS") {
    console.log(job.output_files.out_1);
    break;
  }
  if (job.status === "FAILED") throw new Error(job.error_message);
  await new Promise((resolve) => setTimeout(resolve, 2000));
}

The subtitle filter changes the frames, so video re-encoding is required. You can tune style, codec, and quality, but treat every change as a new output that needs review. Rendi's official FFmpeg cheatsheet also documents custom fonts through fontsdir and FontName. Test the exact font and glyph set before using it across a library.

What Was Actually Tested

On 11 September 2026, the endpoint, request fields, alias rules, status values, and response fields above were checked against Rendi's live OpenAPI file. The exact subtitle filter was also run locally with FFmpeg 8.0.1 against Rendi's public sample video and SRT. It produced a 16-second, 1280 by 720 MP4 with H.264 video and AAC audio, and a frame at five seconds visibly contained the expected caption.

No Rendi cloud job was submitted because this environment did not contain a Rendi API key. The code is schema-checked and the FFmpeg operation is locally verified, but cloud execution is not being claimed.

Poll for Short Jobs, Use Webhooks for Longer Ones

Rendi's status endpoint can return QUEUED, PROCESSING, PREPARED_FFMPEG_COMMAND, FAILED, or SUCCESS. Do not treat an accepted POST as a finished video. Wait for a terminal state, surface error_message on failure, and read the output only after success.

Rendi recommends polling for jobs expected to finish in about 30 seconds or less and using a webhook for longer work. The webhook carries the same completed command data as polling. In production, make the completion handler idempotent, return quickly, and keep polling as a recovery path if webhook delivery eventually fails.

For sensitive outputs, set is_private: true on a paid plan and request a presigned URL when polling. Public storage is the default. A private file has no permanent public URL, and the requested download link can last no more than 7 days.

Inspect the Output Before You Batch

SUCCESS proves that FFmpeg finished. It does not prove that the captions are good. Check both the machine-readable response and the actual picture.

First, confirm that output_files.out_1 exists and that its storage_url opens. Compare the returned duration, dimensions, codec, and file format with the intended delivery. Then watch the entire video with special attention to the first cue, last cue, fastest exchange, line breaks, names, numbers, and captions near cuts or graphic overlays.

Only after that review should the same style preset enter a queue. Store the source-video revision, SRT revision, FFmpeg command, Rendi command ID, output file ID, and reviewer decision together. That record turns a pile of renders into a production system.

The Cost Math Is About Bytes, Not Minutes

Rendi counts the combined size of input and output media. Its pricing example treats a 1 GB input plus a 0.5 GB output as 1.5 GB of processing. Under that exact illustration, the Free plan's 50 GB allowance covers 33 complete jobs with 0.5 GB left, while the entry Pro plan's 250 GB covers 166 complete jobs with 1 GB left.

Those job counts are arithmetic from Rendi's example, not a subtitle benchmark. A real burned MP4 can be larger or smaller depending on the source, codec settings, and output. Measure your own input-plus-output total before forecasting volume.

Free costs $0 per month, includes 50 GB of processing, and limits a command to 1 minute of runtime. Entry Pro costs $25 per month, includes 250 GB, and raises the command cap to 10 minutes. The full Rendi pricing breakdown covers the larger CPU and unlimited-runtime configurations, so there is no reason to repeat that matrix here.

The comparison that matters is operational. Kapwing Pro is listed at $16 per member per month when billed annually, or $24 monthly. A visual editor is easier for an occasional one-off. Rendi makes more sense when caption finishing is a repeatable system step, triggered by approved assets and tracked without another person opening an editor.

Seven Workflows That Benefit Most

The best fit is not everyone who adds captions. It is the team that already has an approved SRT and keeps repeating the final render.

Three Products Worth Building

1. A Brand-Safe Batch Caption Finisher

This is the strongest opportunity. Build a narrow portal for content teams and agencies: accepted video URL, approved SRT, named style preset, review page, and downloadable MP4. The product sells repeatability and approval, not an all-purpose editor.

About 1,900 US searches a month go to add subtitles to a video, while Kapwing Pro starts at $16 per member per month on annual billing. That demand is broad enough to acquire users, and the recurring team workflow is specific enough to support a focused product.

The smallest sellable version needs signed-URL inputs, SRT validation, a handful of locked brand presets, Rendi submission, webhook handling, output metadata, and human accept or reject. The catch is defensibility. A form wrapped around one FFmpeg call is easy to copy. The durable value has to come from approval history, reusable brand rules, revision matching, and dependable failure recovery.

2. An Automation-First Subtitle Render API

Offer one stable endpoint to agencies that do not want their clients exposed to FFmpeg syntax. The customer sends a video URL, SRT URL, preset name, and callback URL. Your service translates the preset into a reviewed command and returns a normalized job result.

Burn subtitles into video records 40 US searches a month and an $8.16 CPC. The volume is small, but the intent is unusually specific. The PAA question, “How can I permanently burn SRT subtitles into a video?”, is almost the product request.

An MVP needs authentication, request validation, Rendi job mapping, idempotency keys, webhook verification, retry-safe state, and usage records. The catch is distribution. Search alone will not support the business, and Rendi already exposes the underlying API. The wrapper has to win through agency integrations, presets, observability, and support.

3. A Caption Preflight and Dual-Output Handoff

Build a review gate that checks one SRT against one final video, then produces a burned review MP4 and a selectable-track delivery MP4 from the approved pair. The buyer is a localization, training, or media-operations team that keeps losing track of which caption revision belongs to which cut.

The real PAA question “How do I add SRT subtitles to a video?” sits beside repeated confusion over permanent and selectable captions in the current results. The product answers both jobs without forcing the operator to choose the container mechanics alone.

The MVP needs cue parsing, duration comparison, safe-area preview, revision IDs, two controlled FFmpeg recipes, and a sign-off record. The catch is that basic SRT validation is a feature, not a company. The review history and handoff controls must be valuable enough that teams keep the product in their release process.

Limits and the Honest Take

Rendi removes FFmpeg infrastructure from this workflow. It does not remove editorial responsibility. It will not correct a transcript, repair bad timing, choose readable line breaks, or decide whether burned captions are the right accessibility format.

It also cannot make burn-in lossless. The subtitle filter changes the video frames, so the video is re-encoded. Quality, runtime, and output size depend on the command and source. The default API safety cap is 300 seconds, while the plan sets the maximum you can request. A long or compute-heavy job needs a plan whose command-runtime ceiling fits the actual encode.

Do not use this path for a single casual clip if a free browser tool already solves the job. Do not burn captions when viewers need to toggle them. Do not batch an unreviewed style. Rendi is compelling when the same approved finishing rule must run reliably across many assets.

The Monday Move

Take one short, approved video and its final SRT. Put both behind fetchable URLs, run the sample payload with your chosen style, inspect the returned metadata, and watch the whole MP4 on the smallest screen you support. Save the accepted command as a preset only after that review. Then connect the preset to the point where your workflow already marks video and captions approved.

If you want this kind of reviewed media pipeline built into your business, see AI production systems.