DEV Community: Javid Jamae

RSS Feed to YouTube Short: Build the Full Pipeline

Javid Jamae — Sun, 28 Jun 2026 10:20:22 +0000

Originally published at ffmpeg-micro.com

Every time a new article drops in your RSS feed, you could turn it into a YouTube Short. Not manually. Fully automated: new post triggers the pipeline, and a finished Short lands in your upload queue.

The Pipeline Architecture

Five stages, each handled by a different tool:

RSS trigger catches new articles (n8n, Make.com, or a cron job)
LLM rewrites the article into a 30-60 second script
TTS converts the script to audio (ElevenLabs, OpenAI TTS)
FFmpeg Micro composites the audio over background video with text overlay
Upload pushes the finished Short to YouTube

Stage 1: RSS Trigger

In n8n, drop an RSS Feed Trigger node pointing at your source feed. It fires every time a new item appears and outputs the article title, link, and content body.

Stage 2: LLM Script Generation

Feed the article body to an LLM with a prompt that outputs a tight script. YouTube Shorts max out at 60 seconds, so aim for 120-180 words.

Stage 3: Text-to-Speech

Send the script to a TTS API (ElevenLabs, OpenAI TTS, or Google Cloud TTS), then upload the audio to FFmpeg Micro for the composition step.

Stage 4: Compose with FFmpeg Micro

This is where it comes together. FFmpeg Micro merges background video with narration audio and adds text overlay:

curl -s -X POST "https://api.ffmpeg-micro.com/v1/transcodes" \
  -H "Authorization: Bearer $FFMPEG_MICRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [
      {"url": "https://your-bucket.com/background-9x16.mp4"},
      {"url": "gs://your-bucket/narration.mp3"}
    ],
    "outputFormat": "mp4",
    "options": [
      {"option": "@text-overlay", "argument": {
        "text": "Your headline here",
        "style": {"charsPerLine": 18, "fontSize": 60, "lineSpacing": 15}
      }}
    ]
  }'

The @text-overlay virtual option handles font rendering, positioning, and line breaking automatically.

Stage 5: Upload to YouTube

Download the finished video and push it to YouTube via the Data API. n8n has a built-in YouTube node that handles this.

Read the full guide with all code examples and pitfalls on ffmpeg-micro.com.

How to Use FFmpeg with Deno (No Installation Required)

Javid Jamae — Sun, 28 Jun 2026 10:19:42 +0000

Originally published at ffmpeg-micro.com

You're building something in Deno and you need video processing. Thumbnail generation, format conversion, transcoding user uploads. You search for "ffmpeg deno" and quickly realize the ecosystem isn't like Node.js. There's no fluent-ffmpeg equivalent.

Deno's security model makes this worse. By default, Deno sandboxes your code. No file system access, no subprocess execution, no network calls unless you explicitly grant permissions.

There are three realistic paths.

Using Deno.Command with a Local FFmpeg Binary

const command = new Deno.Command("ffmpeg", {
  args: ["-i", "input.mp4", "-c:v", "libx264", "-crf", "23", "-preset", "medium", "-c:a", "aac", "-b:a", "192k", "output.mp4"],
  stderr: "piped",
});
const process = command.spawn();
const { code } = await process.status;

You must run this with --allow-run=ffmpeg and --allow-read / --allow-write flags. Works for local scripts but breaks on Deno Deploy.

Using FFmpeg WASM in Deno

import { FFmpeg } from "npm:@ffmpeg/ffmpeg";
import { fetchFile } from "npm:@ffmpeg/util";

const ffmpeg = new FFmpeg();
await ffmpeg.load();
await ffmpeg.writeFile("input.mp4", await fetchFile("./input.mp4"));
await ffmpeg.exec(["-i", "input.mp4", "-c:v", "libx264", "output.mp4"]);
const data = await ffmpeg.readFile("output.mp4");
await Deno.writeFile("output.mp4", data);

No binary needed, but 10-20x slower than native FFmpeg. Fine for lightweight operations only.

Using a Cloud API (FFmpeg Micro)

const response = await fetch("https://api.ffmpeg-micro.com/v1/transcodes", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${Deno.env.get("FFMPEG_MICRO_API_KEY")}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    inputs: [{ url: "https://example.com/video.mp4" }],
    outputFormat: "mp4",
    preset: { quality: "high", resolution: "1080p" },
  }),
});
const job = await response.json();

No npm packages. No binary dependencies. Works everywhere Deno runs, including Deno Deploy.

Read the full guide with polling, download, and advanced examples.

How to Add FFmpeg to an Airtable Automation

Javid Jamae — Sat, 27 Jun 2026 10:18:18 +0000

Originally published at ffmpeg-micro.com

Airtable is great at tracking content. Rows of video files with status columns, due dates, assignees. But when someone changes a status to "Ready to publish" and you still have to manually export, resize, and transcode each video, the automation stops where it matters most.

You can fix this by connecting Airtable's scripting automation to the FFmpeg Micro API. When a record hits a trigger condition, a script fires an HTTP request, FFmpeg Micro processes the video, and the output URL writes back into your Airtable row. No manual step in between.

The Architecture

Airtable automations trigger scripts when records change. Those scripts can make HTTP requests. FFmpeg Micro accepts video URLs over HTTP and returns processed results. The flow:

A record in your Airtable base changes (new row, status update, checkbox toggle)
Airtable fires an automation trigger
A scripting action sends the video URL to the FFmpeg Micro API
FFmpeg Micro transcodes the video and returns a job ID
A second automation polls for completion and writes the download URL back

No middleware. No Zapier. No n8n. Just Airtable's built-in scripting block talking directly to an API.

Step 1: Get Your FFmpeg Micro API Key

Sign up at ffmpeg-micro.com and grab your API key from the dashboard. The free tier gives you enough minutes to test and run small batches.

Step 2: Set Up Your Airtable Base

You need a table with at least these fields:

Field Name	Type	Purpose
Video URL	URL	Source video link (public URL)
Output Format	Single select	mp4, webm, mov
Status	Single select	Pending, Processing, Done, Error
Job ID	Single line text	FFmpeg Micro job ID for polling
Output URL	URL	Where the processed video ends up
Quality	Single select	low, medium, high (optional)

The Video URL field should contain a publicly accessible link. FFmpeg Micro needs to download the source file, so private Airtable attachments won't work directly. Use a public cloud storage URL (Google Cloud Storage, S3, or any CDN).

Step 3: Create the Automation

In Airtable, go to Automations and create a new one:

Trigger: "When record matches conditions"

Table: your video table
Condition: Status = "Pending"

Action: "Run a script"

Paste this script into the scripting action:

const config = input.config();
const recordId = config.recordId;
const videoUrl = config.videoUrl;
const outputFormat = config.outputFormat || 'mp4';
const quality = config.quality || 'medium';

const API_KEY = 'YOUR_FFMPEG_MICRO_API_KEY';

// Update status to Processing
await config.table.updateRecordAsync(recordId, {
    'Status': {name: 'Processing'}
});

// Send transcode request to FFmpeg Micro
const response = await fetch('https://api.ffmpeg-micro.com/v1/transcodes', {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        inputs: [{url: videoUrl}],
        outputFormat: outputFormat,
        preset: {quality: quality}
    })
});

const result = await response.json();

if (response.ok) {
    // Store the job ID for polling later
    await config.table.updateRecordAsync(recordId, {
        'Job ID': result.id
    });
    console.log(`Transcode job created: ${result.id}`);
} else {
    await config.table.updateRecordAsync(recordId, {
        'Status': {name: 'Error'}
    });
    console.error(`FFmpeg Micro error: ${result.error}`);
}

Configure the input variables in the script settings:

recordId = the record ID from the trigger
videoUrl = the Video URL field value
outputFormat = the Output Format field value
quality = the Quality field value
table = the table object (Airtable provides this automatically)

Step 4: Poll for Completion

FFmpeg Micro transcodes are asynchronous. The API returns a job ID immediately, and processing happens in the background. Create a second automation to check job status:

Trigger: "When record matches conditions"

Condition: Status = "Processing" AND Job ID is not empty

Or use a scheduled automation that runs every 5 minutes.

Action: "Run a script"

const config = input.config();
const recordId = config.recordId;
const jobId = config.jobId;
const API_KEY = 'YOUR_FFMPEG_MICRO_API_KEY';

// Check job status
const statusResponse = await fetch(
    `https://api.ffmpeg-micro.com/v1/transcodes/${jobId}`,
    {
        headers: { 'Authorization': `Bearer ${API_KEY}` }
    }
);
const job = await statusResponse.json();

if (job.status === 'completed') {
    // Get downloadable URL (output_url is a gs:// path, not directly fetchable)
    const downloadResponse = await fetch(
        `https://api.ffmpeg-micro.com/v1/transcodes/${jobId}/download`,
        {
            headers: { 'Authorization': `Bearer ${API_KEY}` }
        }
    );
    const download = await downloadResponse.json();

    await config.table.updateRecordAsync(recordId, {
        'Status': {name: 'Done'},
        'Output URL': download.url
    });
} else if (job.status === 'failed') {
    await config.table.updateRecordAsync(recordId, {
        'Status': {name: 'Error'}
    });
}

Most transcodes finish in under a minute for short videos. The polling automation catches results on its next run.

Use Cases That Work Well With This Setup

Batch thumbnail generation. Drop 50 video URLs into Airtable, set all to "Pending," and the automation generates a thumbnail from each one. FFmpeg Micro can extract frames at specific timestamps.

Social media reformatting. Your content team uploads one master video. The automation creates vertical crops for TikTok/Reels, square crops for Instagram feed, and landscape versions for YouTube, all from the same source.

Client delivery. Agencies managing video projects can let clients upload raw footage to a shared Airtable base. The automation transcodes to the client's required format and resolution, then writes the download link back into the record.

Content pipeline tracking. Track every video from draft to published in Airtable, with automated format conversion as part of the workflow. Status columns let your team see exactly where each piece is.

FAQ

Does Airtable's scripting block support fetch/HTTP requests?

Yes. Airtable's scripting automation actions support the standard fetch API for making HTTP requests. You can call any REST API, including FFmpeg Micro, directly from a script.

Can I process Airtable attachment fields directly?

Not directly. Airtable attachment URLs are temporary and authenticated. You need to copy the file to a public storage location first (like Google Cloud Storage or S3), then pass that public URL to FFmpeg Micro.

What happens if the transcode fails?

The polling script checks for failed status and sets the record to "Error." Check the Airtable automation run history for details. Common causes: invalid video URL, unsupported format, or an expired source link.

How many videos can I process at once?

FFmpeg Micro's free tier includes a limited number of processing minutes per month. The API handles concurrent requests, but Airtable automations have their own run limits depending on your plan (25,000 runs/month on Pro).

Is there a way to do this without writing code?

Connect Airtable to FFmpeg Micro through Make.com or Zapier instead of writing scripts. Both platforms have HTTP modules that can call the API without code. But the scripting approach gives you more control over error handling and record updates.

Last verified: June 2026

FFmpeg filter_complex Explained: Multi-Input Processing and Filter Chains

Javid Jamae — Sat, 27 Jun 2026 10:17:51 +0000

Originally published at ffmpeg-micro.com

FFmpeg's -vf flag handles simple, single-stream operations just fine. Scale a video, crop it, add a watermark. But the moment you need two inputs, or want to route one stream through multiple processing paths, -vf breaks down. That's where filter_complex comes in.

filter_complex is FFmpeg's system for building multi-input, multi-output processing graphs. It's also where most developers hit a wall, because the syntax looks like someone spilled regex into a shell command. This guide breaks down how it actually works, with patterns you can copy and modify.

What filter_complex Does That -vf Can't

The -vf flag (and its audio counterpart -af) operates on a single input stream. One video in, one video out. It's a pipeline:

ffmpeg -i input.mp4 -vf "scale=1280:720" output.mp4

filter_complex removes that single-stream constraint. It lets you:

Combine multiple input files (overlay, concat, blend)
Split one input into multiple processing paths
Chain filters across different streams with explicit routing
Produce multiple output files from one command

The syntax is different because it has to be. When you have three inputs and two outputs, you need labels to say which stream goes where.

The Label System

Labels are how filter_complex routes streams. Every input gets an automatic label based on its position and stream type:

[0:v] is the video stream from the first input
[0:a] is the audio stream from the first input
[1:v] is the video stream from the second input

You can also create your own labels for intermediate results. Anything in square brackets before a filter is an input label. Anything after a filter (also in square brackets) is an output label:

-filter_complex "[0:v]scale=1280:720[scaled]"

This takes the video from input 0, scales it to 1280x720, and labels the result [scaled]. You then use -map "[scaled]" to route that labeled stream to an output file.

Labels must be unique within a filtergraph. If you use [out] once, you can't use it again.

Pattern 1: Chain Multiple Filters on One Input

The simplest filter_complex pattern. You want to apply several operations in sequence without running FFmpeg multiple times.

ffmpeg -i input.mp4 \
  -filter_complex "[0:v]scale=1280:720,crop=640:360:320:180[out]" \
  -map "[out]" output.mp4

Filters chained with commas run left to right on the same stream. This scales to 1280x720 first, then crops a 640x360 region from the center.

You could do this with -vf "scale=1280:720,crop=640:360:320:180" and get the same result. The filter_complex version only becomes necessary when you need labels for routing, which leads to the next two patterns.

A more practical chain adds text overlay after scaling:

ffmpeg -i input.mp4 \
  -filter_complex "[0:v]scale=1920:1080,drawtext=text='Demo':fontsize=48:x=10:y=10:fontcolor=white[out]" \
  -map "[out]" output.mp4

Pattern 2: Combine Multiple Inputs

This is the most common reason developers reach for filter_complex. You have two or more files and need to merge them into one output.

Overlay (picture-in-picture):

ffmpeg -i main.mp4 -i webcam.mp4 \
  -filter_complex "[1:v]scale=160:90[pip]; [0:v][pip]overlay=W-w-10:H-h-10[out]" \
  -map "[out]" -map "0:a" output.mp4

Notice the semicolon. In filter_complex, semicolons separate independent filter chains. The first chain scales the second input down. The second chain overlays the scaled result onto the first input.

W and H are the width and height of the background video. w and h are the overlay's dimensions. So W-w-10:H-h-10 puts the overlay 10 pixels from the bottom-right corner.

The -map "0:a" at the end grabs audio from the first input, since filter_complex doesn't automatically pass through audio.

Concatenation (join videos end to end):

ffmpeg -i part1.mp4 -i part2.mp4 -i part3.mp4 \
  -filter_complex "[0:v][0:a][1:v][1:a][2:v][2:a]concat=n=3:v=1:a=1[outv][outa]" \
  -map "[outv]" -map "[outa]" output.mp4

The concat filter takes all input streams in order. n=3 tells it there are 3 segments. v=1:a=1 means each segment has one video and one audio stream.

Pattern 3: Split One Input Into Multiple Outputs

Sometimes you need to produce several versions of the same source video in one pass. The split filter duplicates a stream:

ffmpeg -i input.mp4 \
  -filter_complex "[0:v]split=2[a][b]; [a]scale=320:180[small]; [b]scale=1280:720[big]" \
  -map "[small]" small.mp4 \
  -map "[big]" big.mp4

split=2 creates two copies of the input stream, labeled [a] and [b]. Each copy goes through its own scale filter. Each labeled output maps to a different output file.

This is significantly faster than running FFmpeg twice because you only decode the source once.

Running filter_complex Operations via the FFmpeg Micro API

Writing filter_complex commands by hand is where self-hosted FFmpeg gets painful. The syntax is fiddly, errors are cryptic ("Output pad 'default' of filter..." means you forgot a label), and every typo requires re-reading the docs.

FFmpeg Micro's API handles the most common filter_complex patterns without you writing filtergraph syntax. For operations like overlay, concatenation, and multi-step processing, use the options array:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [
      {"url": "https://example.com/main.mp4"},
      {"url": "https://example.com/overlay.png"}
    ],
    "outputFormat": "mp4",
    "options": [
      {"option": "-c:v", "argument": "libx264"},
      {"option": "-crf", "argument": "23"}
    ]
  }'

The API accepts multiple inputs via the inputs array and lets you pass raw FFmpeg options when you need fine-grained control. For operations that don't need custom filtergraphs (most transcoding, format conversion, quality adjustment), the preset field is even simpler:

{
  "inputs": [{"url": "https://example.com/video.mp4"}],
  "outputFormat": "mp4",
  "preset": {"quality": "high", "resolution": "1080p"}
}

No filter_complex syntax. No stream labels. No debugging "pad already used" errors at 2 AM.

Common Pitfalls

"Output pad already used" error. You tried to use a labeled stream twice without splitting it first. Every label can only be consumed once. Use split to duplicate it.

Audio disappearing. filter_complex doesn't pass through unmapped streams. If your filtergraph only processes video, you need -map "0:a" to keep the audio track.

Semicolons vs. commas. Commas chain filters on the same stream. Semicolons separate independent chains. Mix them up and FFmpeg either errors out or produces garbage.

Forgetting -map. When using filter_complex, FFmpeg won't guess which outputs you want. You must explicitly -map every labeled output to a file. No map, no output.

Label naming. Labels can't contain special characters or spaces. Stick to alphanumeric names: [scaled], [pip], [out], [v1].

FAQ

When should I use filter_complex instead of -vf?

Use filter_complex whenever you have more than one input file, need to split a stream into multiple processing paths, or want multiple output files from one command. If you're doing simple single-input processing (scale, crop, rotate), -vf is simpler and does the same thing.

Can I mix video and audio filters in one filter_complex?

Yes. Video and audio filters run in the same filtergraph. Use video stream labels ([0:v]) and audio stream labels ([0:a]) to route each through their respective filters. Just remember that video filters can't process audio and vice versa.

What does the semicolon do in filter_complex?

Semicolons separate independent filter chains within the filtergraph. Each chain processes its own input and produces its own output. Commas chain filters sequentially on the same stream.

How many inputs can filter_complex handle?

There's no hard limit. FFmpeg can handle dozens of inputs in a single filter_complex command. The practical limit is usually memory and the complexity of your filtergraph. For batch operations with hundreds of files, you're better off running separate commands or using an API.

Does FFmpeg Micro support custom filter_complex commands?

FFmpeg Micro handles the most common multi-input operations (concatenation, overlay, multi-step processing) through its inputs array and options fields. For standard use cases, you don't need to write filtergraph syntax at all. For advanced scenarios requiring raw filter_complex strings, pass them through the options array.

Last verified: June 2026

Notion to Video: Auto-Render on Row Change with Make

Javid Jamae — Fri, 26 Jun 2026 10:19:17 +0000

Originally published at ffmpeg-micro.com

You've got a Notion database full of product names, launch dates, and promo copy. Every time you add or update a row, someone has to manually open a video editor, swap in the new text, export, and upload. That process takes 15 minutes if you're fast.

There's a better way. Connect Notion to Make.com, hit the FFmpeg Micro API on every row change, and get a rendered video back automatically.

Why Notion + Make + FFmpeg Micro

Notion works well as a lightweight CMS. Make.com watches for changes in that Notion database and fires off actions. FFmpeg Micro handles the actual video rendering via a simple REST API.

The full loop: Notion row updates, Make picks it up, Make calls FFmpeg Micro with the row data as a text overlay on a template video, and the rendered file URL comes back in the response.

The FFmpeg Micro API Request

The @text-overlay option burns text directly onto your template video:

{
  "inputs": [
    {"url": "{{1.properties.Template Video URL.url}}"}
  ],
  "outputFormat": "mp4",
  "options": [
    {
      "option": "@text-overlay",
      "argument": {
        "text": "{{1.properties.Title.title[0].plain_text}}",
        "style": {
          "fontSize": 48,
          "charsPerLine": 20,
          "lineSpacing": 12,
          "x": "(w-text_w)/2",
          "y": "(h-text_h)/2"
        }
      }
    }
  ]
}

Test it outside of Make with curl:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.example.com/template.mp4"}],
    "outputFormat": "mp4",
    "options": [{"option": "@text-overlay", "argument": {"text": "Product Launch: Acme Widget", "style": {"fontSize": 48, "charsPerLine": 20, "x": "(w-text_w)/2", "y": "(h-text_h)/2"}}}]
  }'

Common Pitfalls

Triggering on every edit: Gate renders behind a Status value like "Ready to Render"
Template not accessible: FFmpeg Micro fetches via URL, so ensure it's publicly reachable
Text overflow: Set reasonable charsPerLine values for your template
Make.com timeouts: Bump HTTP module timeout to 60+ seconds

FAQ

Does Make.com trigger on new rows or just updates? Both. Use "Watch Database Items" for updates or "Watch Database Items (Created)" for new rows.

How long does a render take? 3-8 seconds for a 30-second template with text overlay.

What formats work? Any format FFmpeg can decode as input, including MP4, MOV, WebM, and AVI.

FFmpeg Overlay Filter: Picture-in-Picture and Compositing

Javid Jamae — Fri, 26 Jun 2026 10:18:29 +0000

Originally published at ffmpeg-micro.com

You need to put one video on top of another, and FFmpeg's documentation reads like a math textbook. The overlay filter is one of the most used filters in FFmpeg, but getting the positioning, scaling, and timing right takes more trial and error than it should.

This guide covers the overlay filter from basic image-on-video compositing to timed picture-in-picture with multiple streams.

How the FFmpeg Overlay Filter Works

The overlay filter takes two video inputs and stacks one on top of the other. The first input is the background (main video), and the second is the foreground (the overlay). You control placement with x and y coordinates.

The basic syntax inside filter_complex:

ffmpeg -i main.mp4 -i logo.png -filter_complex "[0:v][1:v]overlay=10:10" output.mp4

This places logo.png at 10 pixels from the left and 10 pixels from the top of main.mp4. Two inputs, one filter, x and y coordinates.

You need -filter_complex instead of -vf whenever you're working with multiple inputs.

Position Variables for Dynamic Placement

Hardcoding pixel values breaks the moment your input resolution changes. FFmpeg gives you position variables that reference the dimensions of each stream at runtime:

W and H refer to the main video's width and height
w and h refer to the overlay's width and height

Bottom-right corner with 10px padding:

ffmpeg -i main.mp4 -i watermark.png -filter_complex "[0:v][1:v]overlay=W-w-10:H-h-10" output.mp4

Center the overlay:

ffmpeg -i main.mp4 -i overlay.png -filter_complex "[0:v][1:v]overlay=(W-w)/2:(H-h)/2" output.mp4

FFmpeg Picture-in-Picture with Scaling

Chain a scale filter before the overlay:

ffmpeg -i main.mp4 -i pip.mp4 -filter_complex \
  "[1:v]scale=320:180[pip];[0:v][pip]overlay=W-w-20:20" \
  output.mp4

Video-on-Video vs. Image-on-Video

When overlaying video on video, set eof_action to handle duration mismatches:

ffmpeg -i main.mp4 -i overlay.mp4 -filter_complex \
  "[0:v][1:v]overlay=10:10:eof_action=pass" output.mp4

Timed Overlays

Show overlays only during specific time windows:

ffmpeg -i main.mp4 -i lower_third.png -filter_complex \
  "[0:v][1:v]overlay=0:H-h:enable='between(t,5,15)'" output.mp4

Running Overlays via API

FFmpeg Micro runs your overlay commands as API calls. Same filter syntax, no infrastructure:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [
      {"url": "https://storage.example.com/main.mp4"},
      {"url": "https://storage.example.com/overlay.png"}
    ],
    "outputFormat": "mp4",
    "options": [
      {"option": "-filter_complex", "argument": "[0:v][1:v]overlay=W-w-10:H-h-10"}
    ]
  }'

Common Pitfalls

Pixel format mismatches: Use format=auto on the overlay filter for PNG transparency
Missing audio: Add -map 0:a -c:a copy to carry audio through
Using -vf instead of -filter_complex: -vf only works with a single input

FAQ

How do I put a logo in the corner of a video? Use overlay=W-w-10:H-h-10 for bottom-right placement.

Can I overlay video on video? Yes, same syntax. Use eof_action=pass if the overlay is shorter.

How do I make picture-in-picture? Scale first, then overlay: [1:v]scale=320:180[pip];[0:v][pip]overlay=W-w-20:20

How to Post 100 Videos a Week Without Editing Software

Javid Jamae — Thu, 25 Jun 2026 10:17:09 +0000

Originally published at ffmpeg-micro.com

You run a one-person operation. You know you should be posting video content. But you're also the one building the product, handling support, and managing the business. The idea of opening editing software 100 times a week sounds like a joke.

It's not a joke if you take the editor out of the equation.

This post walks through a real pipeline that lets a solo operator publish 100+ videos a week across YouTube Shorts, TikTok, and Instagram Reels without touching editing software once. The whole thing runs on an automation tool, a video processing API, and about 30 minutes of initial setup.

Why 100 Videos Isn't as Crazy as It Sounds

Most people think "100 videos" means 100 shoots. It doesn't. It means having source footage (or templates) and a system that turns them into platform-ready clips automatically.

A 10-minute podcast episode can become 15-20 short clips. A single product demo can be reformatted for three platforms. Five blog posts can turn into five text-on-video pieces per post. The math adds up fast when the system handles the repetitive work.

The bottleneck was never ideas or footage. It was the manual step of opening Premiere, DaVinci, or CapCut, trimming each clip, adding captions, exporting at the right resolution, and doing that over and over.

The Pipeline

The full system has four stages:

Source content goes in. This could be long-form video you've already recorded, podcast episodes, screen recordings, or even just text content that gets turned into video via templates.

An automation tool orchestrates everything. n8n, Make.com, or Zapier watches for new content (a new file in Google Drive, a new row in Airtable, a webhook from your CMS) and kicks off the processing jobs.

FFmpeg Micro handles the video processing. Each job is an API call. Trim to 60 seconds for Shorts. Scale to 9:16 for TikTok. Add a text overlay. Burn in captions. Compress for upload. No FFmpeg install. No server to manage.

The outputs get distributed. The automation tool takes the processed videos and uploads them to each platform, or drops them in a folder for scheduled posting.

A Real Example: Blog Posts to Video Clips

Say you publish 5 blog posts a week. Each post has a headline and 3-4 key points. You want a short video for each key point with text-on-screen overlay. That's 15-20 videos per week from content you already wrote.

The n8n workflow breaks down into three steps:

A webhook fires when a new blog post is published
n8n pulls the title and key points from the post
For each key point, n8n calls FFmpeg Micro to overlay the text on a background video template

The FFmpeg Micro API call for each clip:

{
  "inputs": [{"url": "https://your-bucket.storage.com/background-template.mp4"}],
  "outputFormat": "mp4",
  "options": [
    {
      "option": "@text-overlay",
      "argument": {
        "text": "You don't need editing software to post 100 videos a week",
        "style": {
          "charsPerLine": 20,
          "fontSize": 54,
          "lineSpacing": 12,
          "x": "(w-text_w)/2",
          "y": "(h-text_h)/2",
          "boxBorderW": 10
        }
      }
    }
  ]
}

That's it. One API call per clip. n8n loops through every key point and fires these in parallel.

n8n downloads the finished videos and uploads to YouTube Shorts, TikTok, or a Google Drive folder for batch scheduling

No editing software opened. No manual export. No resizing one clip at a time.

Scaling to 100 a Week

To hit triple digits, combine multiple content sources:

Podcast clips (40-50/week). Record 2 podcast episodes. Each one produces 20-25 clips when you trim at interesting timestamps. FFmpeg Micro handles the trim, the 9:16 crop, and the caption overlay in a single job.

{
  "inputs": [{"url": "https://your-bucket.storage.com/podcast-ep-42.mp4"}],
  "outputFormat": "mp4",
  "options": [
    {"option": "-ss", "argument": "00:04:32"},
    {"option": "-t", "argument": "58"},
    {"option": "-vf", "argument": "crop=ih*9/16:ih,scale=1080:1920"}
  ]
}

Blog-to-video (15-20/week). The text overlay workflow above. Five posts, 3-4 clips each.

Product demos (10-15/week). Record one 20-minute walkthrough and slice it. Each feature gets its own clip.

Reposts across platforms (20-30/week). Take your best-performing clips and reformat them for platforms you haven't posted to yet. A vertical TikTok video becomes a square Instagram post with padding:

{
  "inputs": [{"url": "https://your-bucket.storage.com/tiktok-clip.mp4"}],
  "outputFormat": "mp4",
  "options": [
    {"option": "-vf", "argument": "scale=1080:1080:force_original_aspect_ratio=decrease,pad=1080:1080:(ow-iw)/2:(oh-ih)/2:black"}
  ]
}

Each of these is a single API call. Your automation tool fires them in batch, downloads the results, and either auto-publishes or queues them for review.

What This Actually Costs

FFmpeg Micro charges per minute of video processed. A 60-second short costs about one minute of processing time. At 100 clips per week, you're looking at roughly 100 minutes of processing. The free tier covers small-scale testing. A paid plan handles the full volume.

Compare that to hiring a video editor ($500-2000/month) or spending 20 hours a week in editing software yourself. The math isn't close.

Common Pitfalls

Don't process videos sequentially. Fire API calls in parallel from your automation tool. n8n's "split in batches" node lets you process 10-20 clips at once. Sequential processing turns a 15-minute pipeline into a 3-hour one.

Template backgrounds matter. If your text-on-video clips look generic, it's because the background template is generic. Invest an hour recording 5-10 branded background loops (abstract motion, your office, your product's UI) and rotate through them.

Platform specs change. TikTok updated their preferred aspect ratio in 2025. YouTube Shorts now accepts up to 3 minutes. Build your automation with configurable dimensions and durations so a spec change is a variable update, not a pipeline rebuild.

Don't skip the review step at first. Run the pipeline into a "review" folder for the first week. Spot-check 10% of the output. Once you trust the system, switch to auto-publish.

FAQ

Do I need to know FFmpeg commands to use this? No. FFmpeg Micro's preset system handles common operations (trim, scale, compress) with simple parameters. You only need raw FFmpeg options for custom work like specific filter chains.

What automation tools work with this? Any tool that can make HTTP requests. n8n, Make.com, and Zapier all work. So does a Python script, a Node.js cron job, or a Shortcuts workflow on macOS.

Will the videos look professional? That depends on your source material and templates, not the processing tool. FFmpeg Micro processes video at the same quality as FFmpeg running locally. If your source footage is 1080p, your output is 1080p.

Can I add captions/subtitles automatically? Yes. Pair a transcription API (Whisper, Deepgram, AssemblyAI) with FFmpeg Micro. The transcription API generates the subtitle file, and FFmpeg Micro burns it into the video.

What if a job fails? FFmpeg Micro returns clear error messages on failure. Your automation tool can catch the error and retry or alert you. Failed jobs don't charge processing time.

Last verified: June 2026. API examples use FFmpeg Micro v1.

How to Use FFmpeg with Kotlin (No Installation Required)

Javid Jamae — Thu, 25 Jun 2026 10:16:37 +0000

Originally published at ffmpeg-micro.com

You need video processing in your Kotlin app. Maybe you're building a Spring Boot backend that transcodes user uploads, an Android app that generates social clips, or a Ktor service that watermarks content before delivery. You search "ffmpeg kotlin" and find scattered examples, most from 2019.

FFmpeg handles the video processing. But running it from Kotlin means picking between ProcessBuilder (which works but requires FFmpeg on every machine), a JVM wrapper library, or a cloud API that skips the install entirely. This post covers all three with working Kotlin code.

Running FFmpeg from Kotlin with ProcessBuilder

Kotlin runs on the JVM, so you get Java's ProcessBuilder for free. Install FFmpeg on the machine, then shell out to it:

val process = ProcessBuilder(
    "ffmpeg",
    "-i", "input.mp4",
    "-c:v", "libx264",
    "-crf", "23",
    "-preset", "medium",
    "-c:a", "aac",
    "-b:a", "128k",
    "output.mp4"
).redirectErrorStream(true).start()

process.inputStream.bufferedReader().forEachLine { println(it) }

val exitCode = process.waitFor()
check(exitCode == 0) { "FFmpeg failed with exit code $exitCode" }

This is the simplest path. But you own the FFmpeg install on every server, every CI runner, every Docker image. On Docker, FFmpeg adds 80-200MB. On serverless (Lambda, Cloud Functions), you can't install system binaries at all and the 250MB package limit is tight.

Using Jaffree for a Fluent API

Jaffree is the best JVM wrapper for FFmpeg. It works perfectly from Kotlin and gives you a builder API instead of string arrays:

// build.gradle.kts
dependencies {
    implementation("com.github.kokorin.jaffree:jaffree:2023.09.10")
}

import com.github.kokorin.jaffree.ffmpeg.FFmpeg
import com.github.kokorin.jaffree.ffmpeg.UrlInput
import com.github.kokorin.jaffree.ffmpeg.UrlOutput

FFmpeg.atPath()
    .addInput(UrlInput.fromUrl("input.mp4"))
    .addOutput(
        UrlOutput.toUrl("output.mp4")
            .addArguments("-c:v", "libx264")
            .addArguments("-crf", "23")
            .addArguments("-preset", "medium")
            .addArguments("-c:a", "aac")
            .addArguments("-b:a", "128k")
    )
    .execute()

Jaffree also supports progress tracking, which is useful for showing users a progress bar:

FFmpeg.atPath()
    .addInput(UrlInput.fromUrl("input.mp4"))
    .addOutput(
        UrlOutput.toUrl("output.mp4")
            .addArguments("-c:v", "libx264")
            .addArguments("-crf", "23")
    )
    .setProgressListener { progress ->
        println("Frame: ${progress.frame}, Time: ${progress.timeMark}")
    }
    .execute()

Better than raw ProcessBuilder. But Jaffree still needs FFmpeg on the host. It's a wrapper, not a replacement. You still manage the binary across environments.

Processing Video via Cloud API (No FFmpeg Install)

If you don't want FFmpeg on your machines, offload the work to a cloud API. FFmpeg Micro gives you full FFmpeg capabilities through HTTP. Here's a minimal example using OkHttp, the most common HTTP client in the Kotlin ecosystem:

// build.gradle.kts
dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
    implementation("org.json:json:20240303")
}

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import org.json.JSONArray

val client = OkHttpClient()
val apiKey = System.getenv("FFMPEG_MICRO_API_KEY")

val body = JSONObject().apply {
    put("inputs", JSONArray().put(JSONObject().put("url", "https://example.com/input.mp4")))
    put("outputFormat", "mp4")
    put("preset", JSONObject().apply {
        put("quality", "high")
        put("resolution", "1080p")
    })
}.toString()

val request = Request.Builder()
    .url("https://api.ffmpeg-micro.com/v1/transcodes")
    .header("Authorization", "Bearer $apiKey")
    .header("Content-Type", "application/json")
    .post(body.toRequestBody("application/json".toMediaType()))
    .build()

val response = client.newCall(request).execute()
val result = JSONObject(response.body!!.string())
val jobId = result.getString("id")
println("Job created: $jobId")

No binary to install. No Docker image bloat. No codec management. Send a video URL, pick your settings, get results back.

For advanced operations, pass raw FFmpeg options instead of presets:

val advancedBody = JSONObject().apply {
    put("inputs", JSONArray().put(JSONObject().put("url", "https://example.com/input.mp4")))
    put("outputFormat", "webm")
    put("options", JSONArray().apply {
        put(JSONObject().put("option", "-c:v").put("argument", "libvpx-vp9"))
        put(JSONObject().put("option", "-crf").put("argument", "30"))
        put(JSONObject().put("option", "-b:v").put("argument", "0"))
    })
}.toString()

Polling for Completion

Transcode jobs are async. Poll until the job finishes:

var status = "queued"
while (status == "queued" || status == "processing") {
    Thread.sleep(2000)
    val statusRequest = Request.Builder()
        .url("https://api.ffmpeg-micro.com/v1/transcodes/$jobId")
        .header("Authorization", "Bearer $apiKey")
        .get()
        .build()
    val statusResponse = client.newCall(statusRequest).execute()
    status = JSONObject(statusResponse.body!!.string()).getString("status")
    println("Status: $status")
}

Once the status is completed, grab the download URL:

val downloadRequest = Request.Builder()
    .url("https://api.ffmpeg-micro.com/v1/transcodes/$jobId/download")
    .header("Authorization", "Bearer $apiKey")
    .get()
    .build()

val downloadResponse = client.newCall(downloadRequest).execute()
val downloadUrl = JSONObject(downloadResponse.body!!.string()).getString("url")
// Signed URL valid for 10 minutes

Using Ktor Client Instead

If you're already using Ktor, use its built-in HTTP client instead of adding OkHttp:

// build.gradle.kts
dependencies {
    implementation("io.ktor:ktor-client-core:2.3.12")
    implementation("io.ktor:ktor-client-cio:2.3.12")
    implementation("io.ktor:ktor-client-content-negotiation:2.3.12")
    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
}

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

val client = HttpClient(CIO)

val response = client.post("https://api.ffmpeg-micro.com/v1/transcodes") {
    header("Authorization", "Bearer $apiKey")
    contentType(ContentType.Application.Json)
    setBody("""
        {
            "inputs": [{"url": "https://example.com/input.mp4"}],
            "outputFormat": "mp4",
            "preset": {"quality": "high", "resolution": "1080p"}
        }
    """.trimIndent())
}

println(response.bodyAsText())

Ktor's client is lighter than OkHttp and plays well with coroutines if your backend is already async.

CLI vs. API: Side-by-Side

Same operation (converting MP4 to 720p WebM) done both ways:

FFmpeg CLI (requires local install):

ffmpeg -i input.mp4 -c:v libvpx-vp9 -crf 30 -b:v 0 -vf scale=-2:720 output.webm

FFmpeg Micro API (no install):

val body = JSONObject().apply {
    put("inputs", JSONArray().put(JSONObject().put("url", "https://example.com/input.mp4")))
    put("outputFormat", "webm")
    put("options", JSONArray().apply {
        put(JSONObject().put("option", "-c:v").put("argument", "libvpx-vp9"))
        put(JSONObject().put("option", "-crf").put("argument", "30"))
        put(JSONObject().put("option", "-b:v").put("argument", "0"))
        put(JSONObject().put("option", "-vf").put("argument", "scale=-2:720"))
    })
}.toString()

The CLI version needs FFmpeg installed. The API version runs from any Kotlin app with an HTTP client.

Common Pitfalls

ProcessBuilder path issues on macOS. Kotlin scripts and Gradle tasks don't always inherit your shell PATH. If FFmpeg isn't found, pass the full path (/usr/local/bin/ffmpeg or /opt/homebrew/bin/ffmpeg on Apple Silicon).

Blocking the main thread in Android. Never call ProcessBuilder or make HTTP requests on the main thread. Wrap everything in a coroutine with Dispatchers.IO:

withContext(Dispatchers.IO) {
    val response = client.newCall(request).execute()
    // handle response
}

Jaffree version compatibility. Some older Jaffree versions have issues with FFmpeg 6.x. Use 2023.09.10 or newer.

Large file uploads. For files over 100MB, use FFmpeg Micro's presigned upload flow instead of passing a public URL. Generate a presigned URL, PUT the file directly to cloud storage, confirm the upload, then reference the GCS URL in your transcode request.

FAQ

Can I use FFmpeg on Android directly? Not easily. Android doesn't include FFmpeg, and cross-compiling it for ARM is painful. Mobile FFmpeg (now FFmpeg Kit) works but adds 20-50MB to your APK. A cloud API avoids all of this.

Does Kotlin Multiplatform work with FFmpeg? On JVM targets, yes (ProcessBuilder or Jaffree). On Native or JS targets, no. A cloud API works from any Kotlin target since it's just HTTP.

What's the cost of using a cloud API vs self-hosting? FFmpeg Micro has a free tier for testing and small workloads. For production, pricing is per-minute of video processed. Self-hosting costs server time, maintenance, and your attention when codecs break after an OS update.

Is the API fast enough for real-time processing? FFmpeg Micro is designed for batch and async workflows, not real-time streaming. Jobs typically complete in seconds for short videos. For live streaming, you need a different tool.

How do I handle errors from the API? Check the HTTP status code. 400 means bad request (wrong parameters). 402 means you've hit your quota. 401 means your API key is invalid or expired. The response body always includes an error message.

Last verified: June 2026. Code examples tested against FFmpeg 7.x and FFmpeg Micro API v1.

Build an Automated YouTube Channel That Publishes Itself

Javid Jamae — Wed, 24 Jun 2026 10:15:15 +0000

Originally published at ffmpeg-micro.com

Faceless YouTube channels make money. That's not the interesting part. The interesting part is that most of the work can be automated, and the people doing it well are publishing 30+ videos per week without touching editing software.

The pipeline looks like this: pick a niche, generate scripts, create visuals, compose the video with FFmpeg, and schedule uploads. Each step can be automated. This post walks through the full stack.

Pick a niche that works for automation

Not every YouTube niche is automatable. You need content where the visuals don't require custom footage. That means niches built on stock clips, screen recordings, text overlays, or generated images.

Niches that work well:

Motivational/quote compilations
Reddit story narration
News roundups and "top 10" lists
Educational explainers with slides or diagrams
Product reviews using B-roll and screenshots
Coding tutorials with screen capture

Niches that don't automate well: vlogs, travel content, cooking channels, anything where the camera work IS the content.

The revenue math is simple. YouTube pays roughly $2-8 CPM (cost per 1,000 views) depending on the niche. Finance and tech niches pay closer to $8. Entertainment and gaming hover around $2-3. At 100,000 monthly views with a $5 CPM, that's $500/month. Scale to 300,000 views and you're at $1,500/month.

Script generation with AI

Each video needs a script. For a 60-second Short, that's about 150 words. For a 5-minute explainer, roughly 750 words.

Use Claude, GPT-4, or any capable LLM with a system prompt tailored to your niche:

curl -X POST https://api.anthropic.com/v1/messages \
  -H "x-api-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6-20250514",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Write a 150-word script for a YouTube Short about 5 underrated productivity apps. Punchy, direct, no filler."}]
  }'

For batch production, store your topic list in a spreadsheet or database and loop through it. One API call per script. At scale, you're generating 30+ scripts per week for under $1 in API costs.

Turn scripts into audio with TTS

Text-to-speech has gotten good enough that viewers can't always tell. ElevenLabs and OpenAI's TTS are the top options.

curl -X POST https://api.openai.com/v1/audio/speech \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tts-1",
    "input": "Your script text goes here...",
    "voice": "onyx"
  }' --output narration.mp3

This gives you an MP3 file for each video. Batch it the same way: loop through scripts, generate audio, save to a folder.

Compose the video with FFmpeg

This is where it all comes together. You need to combine background footage, text overlays, and narration into a final video. FFmpeg handles all of it.

Basic composition: background + audio

ffmpeg -i background.mp4 -i narration.mp3 \
  -c:v copy -c:a aac -shortest output.mp4

Add text overlays for key points

ffmpeg -i background.mp4 -i narration.mp3 \
  -vf "drawtext=text='5 Apps You Need':fontsize=48:fontcolor=white:x=(w-text_w)/2:y=100:enable='between(t,0,3)'" \
  -c:a aac -shortest output.mp4

At scale: use the FFmpeg Micro API

When you're processing 30+ videos per week, running FFmpeg locally becomes a bottleneck. Server resources, queue management, error handling. The FFmpeg Micro API handles all of that.

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [
      {"url": "https://storage.example.com/background.mp4"},
      {"url": "https://storage.example.com/narration.mp3"}
    ],
    "outputFormat": "mp4",
    "options": [
      {"option": "-c:v", "argument": "libx264"},
      {"option": "-c:a", "argument": "aac"},
      {"option": "-shortest", "argument": ""}
    ]
  }'

FFmpeg Micro processes the video in the cloud, scales automatically, and returns a download URL when it's done. No server to manage. No FFmpeg to install. You pay per minute of video processed.

Automate the full pipeline with n8n or Make

The glue that connects everything is a workflow automation tool. n8n and Make.com both work. The workflow:

Trigger: New row in a Google Sheet (or cron schedule)
Script generation: Call Claude/GPT API with the topic
TTS: Send script to ElevenLabs or OpenAI TTS, save the audio file
Upload assets: Push background video and audio to cloud storage
Compose: Call FFmpeg Micro API to combine assets
Poll for completion: Check job status until done
Download: Grab the output video URL
Upload to YouTube: Use the YouTube Data API to publish

Each step is an HTTP request. No custom code required if you're using n8n or Make. The entire pipeline runs on a schedule.

The math at 30 videos per week

Running this pipeline at 30 videos per week costs roughly:

Script generation (LLM): ~$3/month (150-word scripts are cheap)
TTS: ~$15/month (ElevenLabs starter plan or OpenAI TTS at $15/1M characters)
Video processing (FFmpeg Micro): ~$10-20/month depending on video length
Automation (n8n Cloud or Make): ~$20/month
Total: ~$50-60/month

Against potential YouTube ad revenue of $500-1,500/month at 100k-300k views, the margins are strong. The timeline to 100k monthly views varies wildly by niche, but channels publishing daily content consistently tend to hit it within 6-12 months.

What separates channels that make money from channels that don't

Volume alone isn't enough. The channels that actually monetize share a few patterns:

They pick high-CPM niches. A finance channel earning $8 CPM needs 125,000 views for $1,000/month. An entertainment channel at $2 CPM needs 500,000 views for the same revenue. Niche selection is the highest-leverage decision in the whole pipeline.

They optimize thumbnails and titles. Automated content production means nothing if nobody clicks. Spend time on thumbnails (Canva templates work), and test titles. This is the one step that benefits from human judgment.

They batch process. Instead of making one video at a time, they generate a week's worth of scripts, produce all the audio, compose all the videos, and schedule everything in one session. The pipeline described above does exactly this.

They reinvest early revenue. First $500/month goes into better stock footage subscriptions, higher-quality TTS voices, or a second channel in a different niche.

FAQ

How many videos per week should I publish?

Start with 5-7. Increase to daily (7/week) once your pipeline is stable. Channels doing 30+ per week usually have multiple series or formats running in parallel.

Do faceless channels get monetized by YouTube?

Yes. YouTube's Partner Program requires 1,000 subscribers and 4,000 watch hours (or 10M Shorts views). Content type doesn't matter as long as it's original and provides value. Compilations of other people's content get flagged. Original scripts with stock footage do not.

Can I use this for YouTube Shorts specifically?

Absolutely. Shorts are actually easier to automate because they're 60 seconds max. Shorter scripts, simpler compositions, faster processing. And Shorts can drive subscribers fast, which helps you hit the monetization threshold.

What's the best automation tool for this?

n8n if you want self-hosted control and unlimited workflows. Make.com if you want a visual builder and don't mind the per-operation pricing. Both integrate with FFmpeg Micro, YouTube, and LLM APIs.

Is this against YouTube's terms of service?

No. YouTube's policies target spam, misleading content, and reused content without added value. Original scripts, original compositions, and genuine informational content are fine. Channels that just re-upload other people's videos get taken down. Channels that automate original content production don't.

Last verified: June 2026. API examples use FFmpeg Micro v1, Claude API, and OpenAI TTS.

FFmpeg -c copy Explained: How to Remux Video Without Re-encoding

Javid Jamae — Wed, 24 Jun 2026 10:14:49 +0000

Originally published at ffmpeg-micro.com

You have an MKV file. Your player needs MP4. The video and audio codecs inside are already perfect. Re-encoding the whole thing would take minutes, burn CPU, and quietly degrade quality.

The fix is one flag: -c copy.

What -c copy actually does

FFmpeg's -c copy tells the encoder to skip encoding entirely. It copies the raw video and audio bitstreams from the input container into the output container without touching a single frame. This process is called remuxing.

The difference is massive:

Operation	Time (1 min video)	CPU usage	Quality loss
Re-encode (libx264, CRF 23)	15-45 seconds	100%	Yes (generational)
Stream copy (-c copy)	Under 1 second	Near zero	None

Remuxing is instant because there's no decode-encode cycle. FFmpeg reads packets from the source container and writes them to the target container. That's it.

When to use -c copy (and when not to)

Use -c copy when:

You're changing containers (MKV to MP4, MP4 to MKV, AVI to MP4)
You need to extract a single stream (pull audio out of a video, pull video without audio)
You're adding faststart for web delivery without re-encoding
You want to strip metadata or chapters while keeping the media intact

Don't use -c copy when:

The source codec isn't compatible with the target container (VP9 in an MP4 container will fail in most players)
You need to change resolution, bitrate, or codec
You're trimming and need frame-accurate cuts (stream copy can only cut on keyframes)

Common remux operations

Change container: MKV to MP4

The most common remux. MKV files with H.264 video and AAC audio drop into MP4 containers without issues.

ffmpeg -i input.mkv -c copy output.mp4

Add faststart for web streaming

MP4 files store their metadata (the "moov atom") at the end by default. Browsers need that metadata before they can start playing. The -movflags +faststart flag moves it to the front so the video starts playing immediately instead of downloading the whole file first.

ffmpeg -i input.mp4 -c copy -movflags +faststart output.mp4

Extract audio from video

Pull the audio track out without re-encoding. The output format should match the audio codec. If the source has AAC audio, output to .aac or .m4a. If it's Opus, output to .ogg or .opus.

ffmpeg -i input.mp4 -c:a copy -vn audio-only.aac

The -vn flag tells FFmpeg to drop the video stream entirely. The -c:a copy copies the audio bitstream as-is.

Extract video without audio

ffmpeg -i input.mp4 -c:v copy -an video-only.mp4

Same idea, reversed. -an drops audio, -c:v copy keeps video untouched.

Remux multiple files in a batch

When you have a folder of MKV files that need to be MP4:

for f in *.mkv; do
  ffmpeg -i "$f" -c copy "${f%.mkv}.mp4"
done

Remuxing with the FFmpeg Micro API

If you're processing videos in an application or automation workflow, you can remux through the FFmpeg Micro API. No FFmpeg installation needed.

Container change via API

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.example.com/input.mkv"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-c", "argument": "copy"},
      {"option": "-movflags", "argument": "+faststart"}
    ]
  }'

This queues a remux job that copies all streams into an MP4 container with faststart enabled. The response includes a job ID you can poll:

{
  "id": "abc-123",
  "status": "queued",
  "billableMinutes": 0.5
}

Extract audio via API

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.example.com/input.mp4"}],
    "outputFormat": "aac",
    "options": [
      {"option": "-c:a", "argument": "copy"},
      {"option": "-vn", "argument": ""}
    ]
  }'

Both operations complete in seconds because there's no re-encoding involved. You only pay for the input duration, and the processing time is minimal.

Common pitfalls

Codec/container mismatch. Not every codec fits in every container. VP9 video works in WebM and MKV but most players choke on VP9 inside MP4. If your remux produces a file that won't play, check whether the codec is compatible with the target container.

Keyframe-only cuts. When you combine -c copy with -ss (seek) and -t (duration) for trimming, FFmpeg can only cut at keyframe boundaries. Your trim points might be off by a few frames. If you need frame-exact cuts, you'll need to re-encode at least the video stream.

Missing moov atom on interrupted encodes. If an MP4 encode was interrupted, the moov atom never got written. You can't fix this with -c copy because the container metadata is corrupt. Tools like untrunc or recover_mp4 can sometimes reconstruct it, but that's outside FFmpeg's scope.

Audio codec mismatch in MKV to MP4. MKV files sometimes contain audio in formats that MP4 doesn't support well (like Vorbis or FLAC). The remux will succeed, but playback might fail. In that case, copy the video but re-encode just the audio: -c:v copy -c:a aac.

FAQ

Is -c copy the same as -codec copy?

Yes. -c copy is shorthand for -codec copy. Both tell FFmpeg to copy all streams without re-encoding. You can also be specific per stream: -c:v copy for video only, -c:a copy for audio only.

Does -c copy reduce file size?

Not directly. Since no re-encoding happens, the bitstream stays the same size. The file might be slightly smaller or larger depending on container overhead differences between MKV and MP4, but we're talking kilobytes, not megabytes.

Can I remux a WebM file to MP4?

It depends on the codecs. If the WebM contains VP8 or VP9 video, putting it in an MP4 container is technically possible but playback support is inconsistent. If it contains H.264 (rare in WebM), the remux to MP4 works fine. For VP9 to MP4 conversion that actually plays everywhere, you'd need to re-encode to H.264.

How do I check what codecs are in my file?

ffmpeg -i input.mkv

Look for the "Stream" lines. They'll show something like Stream #0:0: Video: h264 and Stream #0:1: Audio: aac. If both are compatible with your target container, -c copy will work.

Why is my remuxed file slightly different in size?

Container formats have different overhead. MKV and MP4 store metadata differently, use different packet framing, and have different alignment requirements. A few KB difference is normal and expected.

Last verified: June 2026. CLI examples tested with FFmpeg 7.x, API examples use FFmpeg Micro v1.

Repurpose a Podcast Episode into 10 Social Clips Automatically

Javid Jamae — Tue, 23 Jun 2026 10:20:25 +0000

Originally published at ffmpeg-micro.com

Podcast clipping SaaS tools like Opus Clip, Riverside, Podcastle, and Descript charge between $19 and $500 per month. If you're a solo creator, an agency, or an automation builder, there's a cheaper way: FFmpeg.

The Pipeline

Start with one full podcast episode
Trim clips with -ss and -t
Resize for each platform (9:16 vertical, 1:1 square, 16:9 landscape)
Add text overlays for muted autoplay
Batch all 10 clips through a script or API

Trim a Clip

ffmpeg -i podcast.mp4 -ss 00:12:30 -t 00:00:45 -c copy clip1.mp4

Or via the FFmpeg Micro API:

{
  "inputs": [{"url": "https://storage.example.com/podcast-ep42.mp4"}],
  "outputFormat": "mp4",
  "options": [
    {"option": "-ss", "argument": "00:12:30"},
    {"option": "-t", "argument": "00:00:45"},
    {"option": "-c:v", "argument": "libx264"},
    {"option": "-crf", "argument": "23"}
  ]
}

Resize for Vertical (9:16)

ffmpeg -i clip1.mp4 -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2" vertical-clip1.mp4

Cost Comparison

Tool	Monthly Cost
Opus Clip	$19-$39/mo
Riverside	$24/mo+
Descript	$24-$33/mo
FFmpeg Micro	Pay-per-minute, free tier

A 1-hour podcast split into 10 clips costs pennies with FFmpeg Micro. Not $24. Pennies.

Common Pitfalls

-c copy cuts on keyframes only (may start early)
Re-encode audio too (-c:a aac) to avoid drift
Add -pix_fmt yuv420p for social platform compatibility
Keep CRF at 23 or lower for mobile viewing

Read the full guide at ffmpeg-micro.com/blog/repurpose-podcast-social-clips-ffmpeg

How to Encode VP9 Video with FFmpeg: libvpx-vp9 CRF, Bitrate, and Quality Guide

Javid Jamae — Tue, 23 Jun 2026 10:19:13 +0000

Originally published at ffmpeg-micro.com

VP9 is Google's open, royalty-free video codec. It powers most of YouTube's streaming library, and every modern browser supports it through the WebM container. If you need high-quality web video without licensing headaches, VP9 with FFmpeg's libvpx-vp9 encoder is the standard choice.

This guide covers the practical settings: CRF mode, 2-pass encoding, speed tuning, and multithreading.

TL;DR: The Default VP9 Command

ffmpeg -i input.mp4 -c:v libvpx-vp9 -crf 31 -b:v 0 -c:a libopus -b:a 128k output.webm

CRF 31 with -b:v 0 gives you true constant-quality mode. Opus audio at 128k is the natural pairing for WebM.

What CRF Does in VP9

VP9's CRF scale runs from 0 to 63. Lower means better quality and bigger files. This is different from H.264's libx264, which uses a 0-51 range.

You must set -b:v 0 for true CRF mode. If you leave out -b:v 0, FFmpeg treats the CRF value as a constrained quality floor. This is the single most common VP9 encoding mistake.

VP9 CRF Values by Use Case

CRF	Use Case	Notes
15-20	Archival / master copies	Near-lossless. Large files.
24-28	High-quality streaming	Visually transparent for most content
30-33	General web video	Good quality at reasonable file sizes
36-42	Low-bandwidth delivery	Noticeable softness, but watchable
45+	Previews / thumbnails	Significant quality loss

Speed Settings

-cpu-used is a number from 0 to 8. Zero is the slowest and highest quality. For most encodes, -deadline good -cpu-used 2 is the sweet spot.

2-Pass Encoding

ffmpeg -i input.mp4 -c:v libvpx-vp9 -b:v 2M -deadline good -cpu-used 2 -row-mt 1 -pass 1 -an -f null /dev/null
ffmpeg -i input.mp4 -c:v libvpx-vp9 -b:v 2M -deadline good -cpu-used 2 -row-mt 1 -pass 2 -c:a libopus -b:a 128k output.webm

Multithreading

Always enable -row-mt 1. It can cut encode time by 50% or more with no quality penalty.

Common Pitfalls

Forgetting -b:v 0 in CRF mode
Using -cpu-used 0 (extremely slow)
Skipping -row-mt 1
Using .mp4 container (use .webm instead)

Read the full guide with API examples at ffmpeg-micro.com/blog/ffmpeg-vp9-encoding-libvpx-guide