DEV Community: Javid Jamae

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

Remotion + FFmpeg Micro: Programmatic Video Without the Lambda Bill

Javid Jamae — Mon, 22 Jun 2026 18:57:53 +0000

Originally published at ffmpeg-micro.com

Remotion lets you build videos the same way you build React components. But moving those compositions from your local dev server to a production pipeline usually means setting up AWS Lambda, managing cold starts, and watching your bill climb with every render. The post-processing step, compressing, converting, and combining your rendered output, doesn't need any of that infrastructure. FFmpeg Micro handles it with a single API call.

TL;DR: Use Remotion to compose and render your videos. Use FFmpeg Micro's API to compress, convert, add audio, and batch-process the output. No Lambda configuration, no self-hosted FFmpeg binaries, no DevOps overhead.

Where Remotion Ends and FFmpeg Starts

Remotion is a composition and rendering tool. You define scenes in React, animate them with code, and export frames to video. It's excellent at that job.

But rendering is only half the pipeline. After Remotion hands you an MP4, you still need to compress it for delivery, convert it to WebM for browser compatibility, mix in a background music track, or pull a thumbnail frame for your Open Graph tags. That's FFmpeg territory.

The traditional approach is to install FFmpeg on a server, write shell scripts, and manage the infrastructure yourself. Or you bolt FFmpeg onto the same Lambda setup you're already using for Remotion rendering, adding complexity to a system that's already complex enough.

FFmpeg Micro gives you a REST API instead. POST your video URL, specify what you want, and poll for the result. It runs on managed infrastructure, so you don't install anything.

Compress Remotion Output

Remotion renders tend to be large. A 60-second 1080p composition can easily produce a 200MB+ file because Remotion prioritizes quality over file size during rendering. That's fine for an intermediate artifact, but you can't serve a 200MB video to users.

FFmpeg Micro's preset system handles compression in one call:

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://your-bucket.s3.amazonaws.com/remotion-render.mp4"}],
    "outputFormat": "mp4",
    "preset": {"quality": "high", "resolution": "1080p"}
  }'

The quality preset maps to a sensible CRF value and encoding configuration, so you don't need to memorize FFmpeg flags. For most Remotion output, the "high" preset cuts file size by 60-80% with no visible quality loss.

For more control over compression settings, see the full guide on compressing video with the FFmpeg Micro API.

Convert to WebM or MOV

Remotion outputs MP4 by default. If you need WebM for better browser-native playback or MOV for Apple ecosystem delivery, change the outputFormat and specify your codec:

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://your-bucket.s3.amazonaws.com/remotion-render.mp4"}],
    "outputFormat": "webm",
    "options": [
      {"option": "-c:v", "argument": "libvpx-vp9"},
      {"option": "-crf", "argument": "30"},
      {"option": "-b:v", "argument": "0"}
    ]
  }'

Setting -b:v to 0 tells VP9 to use constant quality mode, letting the CRF value drive the quality-to-size tradeoff. This is the recommended approach for WebM encoding when you care more about consistent quality than hitting a specific bitrate target.

Need to support multiple formats from a single Remotion render? Fire off parallel API calls for each format. The format conversion guide covers the full set of supported output types.

Add Background Audio to a Rendered Video

Remotion supports audio in compositions, but sometimes you want to add music or voiceover after rendering. Maybe your audio asset wasn't ready during the render step. Maybe you're A/B testing different background tracks against the same video.

FFmpeg Micro accepts multiple inputs, so you can merge a video and audio file in a single request:

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://your-bucket.s3.amazonaws.com/remotion-render.mp4"},
      {"url": "https://your-bucket.s3.amazonaws.com/background-music.mp3"}
    ],
    "outputFormat": "mp4",
    "options": [
      {"option": "-shortest", "argument": ""}
    ]
  }'

The -shortest flag trims the output to the length of the shorter input, so a 3-minute music track won't extend a 45-second video with silence. The API supports up to 10 inputs per request, which also opens the door to concatenating separately rendered Remotion segments (intros, outros, chapters) into a single deliverable.

More audio mixing patterns are covered in the audio merging guide.

Batch Processing Personalized Videos

This is where the Remotion + FFmpeg Micro combination really shines. Say you're rendering 500 personalized onboarding videos, each with a different user's name and data. Remotion handles the personalized rendering. FFmpeg Micro handles the post-processing at scale.

A simple TypeScript helper to kick off batch compression:

async function processRemotionBatch(videoUrls: string[], apiKey: string) {
  const jobs = await Promise.all(
    videoUrls.map(url =>
      fetch('https://api.ffmpeg-micro.com/v1/transcodes', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          inputs: [{ url }],
          outputFormat: 'mp4',
          preset: { quality: 'high', resolution: '1080p' }
        })
      }).then(r => r.json())
    )
  );
  return jobs;
}

Each call returns a job ID. Poll GET /v1/transcodes/{id} until the status flips from processing to completed, then grab the download URL from GET /v1/transcodes/{id}/download. For large batches, add a concurrency limiter so you don't fire 500 requests simultaneously.

You can also extract thumbnail frames from each rendered video for email previews or social cards. The thumbnail generation guide walks through that workflow.

Common Pitfalls

Remotion's default codec may surprise you. Remotion typically outputs H.264 in an MP4 container, but the encoding settings vary based on your Remotion config. If you're passing the output to FFmpeg Micro with custom options (not presets), make sure your flags are compatible with the input codec. When in doubt, use the preset system and let FFmpeg Micro pick the right encoding chain.

Large renders need the presigned upload flow. If your Remotion output lives on a public URL (S3, GCS, R2), pass it directly as an input URL. But if you're rendering locally and the file is only on disk, you'll need to upload it first. FFmpeg Micro provides a three-step flow: POST /v1/upload/presigned-url to get a signed GCS URL, PUT the file to that URL, then POST /v1/upload/confirm to register it. Use this instead of trying to serve files from localhost.

Poll, don't webhook. FFmpeg Micro uses a polling model for job status. Hit GET /v1/transcodes/{id} on an interval. A job moves through queued, processing, and then settles on completed or failed. A 2-3 second polling interval works well for most video lengths. Don't assume the job is done just because the POST returned 201. That 201 means the job was accepted, not finished.

FAQ

Can FFmpeg Micro fully replace Remotion Lambda for rendering?
No. FFmpeg Micro is a post-processing API, not a rendering engine. You still need Remotion (locally, via Lambda, or via Remotion Cloud) to turn your React compositions into video files. FFmpeg Micro picks up after the render step for compression, conversion, and audio mixing.

What's the maximum file size FFmpeg Micro can process?
The presigned upload flow supports files up to 2GB through Google Cloud Storage. For URL-based inputs, there's no strict limit on the API side. Most Remotion renders, even long-form content at 1080p, won't hit a size constraint.

Is it cheaper than running FFmpeg on Lambda?
For post-processing tasks, yes. AWS Lambda bills by duration and memory. A 10-minute 1080p transcode on Lambda with 3GB memory costs roughly $0.30 per run, and you still need to manage the deployment, layers, and timeout configuration. FFmpeg Micro charges per job with predictable pricing and zero infrastructure management.

Can I chain multiple FFmpeg operations on the same video?
Each API call runs one operation. If you need to compress and then convert to WebM, that's two sequential calls. Use the download URL from the first job as the input URL for the second. In practice, you can often combine operations into a single call by passing the right combination of options and output format.

Does FFmpeg Micro support Remotion's transparent video (ProRes) output?
If you configure Remotion to output ProRes in a MOV container, you can pass that URL to FFmpeg Micro and convert it to any supported format. This is useful when you need an alpha channel during composition but want to deliver H.264 MP4 to end users.

Ready to skip the Lambda configuration? Grab a free API key at ffmpeg-micro.com and start processing your Remotion renders in minutes.

How to Change Video Frame Rate with FFmpeg

Javid Jamae — Mon, 22 Jun 2026 18:57:38 +0000

Originally published at ffmpeg-micro.com

Different platforms demand different frame rates. A 60fps screen recording won't fly on a broadcast system expecting 29.97fps, and uploading 24fps cinema footage to a platform that expects 30fps can cause playback stutters. FFmpeg gives you several ways to handle frame rate conversion, but the options can be confusing. This guide covers the practical approaches that actually work.

Quick answer: To change a video's frame rate to 30fps with FFmpeg, run ffmpeg -i input.mp4 -r 30 output.mp4. This re-encodes the video and adjusts the frame timing to match the new rate.

Check Your Current Frame Rate

Before converting anything, check what you're working with. Use ffprobe to inspect the video:

ffprobe -v error -select_streams v:0 -show_entries stream=r_frame_rate,avg_frame_rate -of default=noprint_wrappers=1 input.mp4

This prints both the stream's base frame rate (r_frame_rate) and the average frame rate (avg_frame_rate). You'll see output like:

r_frame_rate=30/1
avg_frame_rate=30/1

A value of 30/1 means exactly 30fps. You might also see 30000/1001, which is the NTSC standard 29.97fps. Knowing your source frame rate helps you pick the right conversion approach.

Change Frame Rate with the -r Flag

The simplest way to change frame rate is the -r output flag. Place it after your input file:

ffmpeg -i input.mp4 -r 24 output.mp4

This re-encodes the entire video and sets the output to exactly 24fps. FFmpeg automatically drops or duplicates frames to hit the target rate. If your source is 60fps and you target 24fps, FFmpeg drops roughly 60% of the frames. If you go the other direction, from 24fps up to 60fps, it duplicates frames to fill the gaps.

The -r flag is the go-to method for most frame rate conversions. It handles the math for you and keeps audio in sync automatically.

Change Frame Rate with the fps Filter

For more control over how frames are selected during conversion, use the fps video filter:

ffmpeg -i input.mp4 -vf "fps=60" output.mp4

The fps filter lets you specify rounding behavior, which matters when the source and target frame rates don't divide evenly. You can control how FFmpeg rounds timestamps:

ffmpeg -i input.mp4 -vf "fps=fps=30:round=near" output.mp4

The round parameter accepts near (nearest, the default), up, down, and zero (round toward zero). This level of control is useful when you need frame-accurate output for editing workflows or broadcast delivery.

Both the -r flag and the fps filter re-encode the video. There's no way to change frame rate without re-encoding, since the frame timing data is baked into the compressed stream.

Common Frame Rates and When to Use Them

Frame Rate	Common Name	Typical Use
24fps	Film	Cinema, narrative content, film-look videos
25fps	PAL	European broadcast television
29.97fps	NTSC	North American broadcast television
30fps	Web	YouTube, social media, web video
60fps	High frame rate	Gaming footage, sports, smooth motion

Most web video does fine at 30fps. If you're targeting YouTube or social platforms, 30fps is a safe default. For cinematic content, 24fps gives you that film-look cadence. And if you're working with broadcast delivery, match the regional standard: 29.97fps for NTSC territories, 25fps for PAL.

Frame Rate Conversion via API

If you're building frame rate conversion into an application or pipeline, the FFmpeg Micro API lets you run FFmpeg operations over HTTP without managing servers or FFmpeg installations.

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/input.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-r", "argument": "30"}
    ]
  }'

The API accepts the same FFmpeg flags you'd use on the command line. The options array takes objects with option and argument fields. You point it at a source URL, specify your output format, and get back a processed file.

This is especially useful when you need to normalize frame rates across user-uploaded content, or when your backend needs to convert video without installing FFmpeg on every server.

Try frame rate conversion via API. You can get a free API key at ffmpeg-micro.com.

Common Pitfalls

Input -r vs. output -r. Placing -r before the input file changes how FFmpeg interprets the source timing, not the actual output frame rate:

# This changes input interpretation, NOT output frame rate
ffmpeg -r 15 -i input.mp4 -c copy output.mp4

This is mainly useful for raw video or image sequences where there's no embedded timing information. For normal video files, always place -r after the input (-i) to set the output frame rate.

Frame duplication is not interpolation. When you upscale from 24fps to 60fps, FFmpeg duplicates existing frames. It doesn't generate new in-between frames. The result looks identical to the 24fps source, just with repeated frames. If you need actual motion interpolation (generating new frames between existing ones), you'd need the minterpolate filter, which is significantly slower and sometimes produces artifacts.

Audio stays synced. Both the -r flag and the fps filter keep audio in sync automatically. FFmpeg adjusts the video timeline without touching the audio stream. You don't need to add any extra flags for audio synchronization during frame rate conversion.

FAQ

Does changing frame rate affect video quality?
Changing frame rate requires re-encoding, which means a generation loss in quality. You can minimize this by using a high-quality codec like H.264 or H.265 with a reasonable CRF value (e.g., -crf 18). But going from 60fps down to 24fps means permanently discarding 60% of your frames.

Can I change frame rate without re-encoding?
No. Frame rate is embedded in the video stream's timing data. You can't change it with -c copy (stream copy) in any meaningful way. The video must be decoded and re-encoded with the new frame timing.

What happens to variable frame rate (VFR) video?
Screen recordings and phone videos often use variable frame rate. Running them through FFmpeg with -r 30 or -vf "fps=30" converts them to constant frame rate (CFR), which fixes many editing and playback issues. This is actually one of the most common reasons to do a frame rate conversion.

How do I convert 29.97fps to exactly 30fps?
Use the fractional notation: ffmpeg -i input.mp4 -r 30 output.mp4. If your source is 29.97fps (30000/1001), FFmpeg handles the slight timing adjustment. For the reverse, targeting NTSC: ffmpeg -i input.mp4 -r 30000/1001 output.mp4.

Should I change frame rate before or after other edits?
Do your frame rate conversion early in the pipeline, especially if you're also changing video speed or cropping and resizing. Converting frame rate first gives your other filters a consistent time base to work with. If you're extracting frames from the video, convert the frame rate first so you get the right number of output images.

Build an AI Video Editing Agent with Claude and FFmpeg Micro MCP

Javid Jamae — Fri, 19 Jun 2026 10:15:23 +0000

Originally published at ffmpeg-micro.com

Most developers using AI for video editing are still doing it manually. They prompt Claude or ChatGPT to generate an FFmpeg command, copy it, paste it into a terminal, debug the errors, and repeat. That works for one-off jobs. But if you're building a product or workflow where users describe video edits in plain English and get results back automatically, you need something different.

You need an agent. An AI agent that understands video operations, calls the right API, and returns the finished video without anyone touching a terminal.

This tutorial builds exactly that using Claude and the FFmpeg Micro MCP server. By the end, you'll have a working agent that takes natural language instructions like "trim this video to the first 30 seconds and convert it to 720p" and executes the entire job.

What You're Building

The flow looks like this:

User describes a video edit in plain English
Claude interprets the request and picks the right FFmpeg operations
The MCP server calls the FFmpeg Micro cloud API
The API processes the video and returns a download URL
The agent delivers the result

No local FFmpeg installation. No shell commands. No manual intervention after the initial prompt.

Prerequisites

You need three things:

An FFmpeg Micro account. Sign up at ffmpeg-micro.com (free tier works for testing).
Claude Desktop, Claude Code, or Cursor. Any MCP-compatible AI tool works.
2 minutes for setup. The MCP server config is a single JSON block.

Step 1: Connect the FFmpeg Micro MCP Server

Add this to your MCP configuration file:

{
  "mcpServers": {
    "ffmpeg-micro": {
      "type": "http",
      "url": "https://mcp.ffmpeg-micro.com"
    }
  }
}

The first time you use it, your browser opens for OAuth sign-in. After that, the token is cached.

Config file locations:

Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (Mac)
Claude Code: project-level .mcp.json or ~/.claude.json
Cursor: Settings > Cursor Settings > MCP

If your tool doesn't support HTTP MCP yet, use the stdio transport instead:

{
  "mcpServers": {
    "ffmpeg-micro": {
      "command": "npx",
      "args": ["-y", "@ffmpeg-micro/mcp-server"],
      "env": {
        "FFMPEG_MICRO_API_KEY": "your_api_key_here"
      }
    }
  }
}

Step 2: Understand the Available Tools

Once connected, Claude can call six MCP tools:

Tool	What It Does
`transcode_video`	Creates a transcode job (returns immediately)
`transcode_and_wait`	Creates a job and polls until it finishes
`get_transcode`	Checks the status of a specific job
`list_transcodes`	Lists recent jobs with optional filters
`get_download_url`	Generates a signed download link
`cancel_transcode`	Cancels a queued or in-progress job

For most agent workflows, transcode_and_wait is the one you want. It creates the job and blocks until the video is ready, so the agent can return the download link in a single turn.

Step 3: Run Your First Agent Command

Open Claude (or whichever tool you connected) and try this:

Take this video and convert it to 720p MP4 with medium quality:
https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4

Claude reads your request, picks the right tool (transcode_and_wait), constructs the API call with the correct parameters, and waits for the result. You get back a download URL for the processed video.

Behind the scenes, the MCP call looks like this:

{
  "inputs": [
    { "url": "https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4" }
  ],
  "outputFormat": "mp4",
  "preset": {
    "quality": "medium",
    "resolution": "720p"
  }
}

You didn't write that JSON. Claude figured it out from your plain English instruction.

Step 4: Try More Complex Operations

The agent handles more than basic transcoding. Try these:

Extract audio from a video:

Extract the audio from this video as an MP3:
https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4

Compress for web delivery:

Compress this video for web. Target quality CRF 28, use H.265 encoding:
https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4

Claude translates that into the right FFmpeg options:

{
  "inputs": [
    { "url": "https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4" }
  ],
  "outputFormat": "mp4",
  "options": [
    { "option": "-c:v", "argument": "libx265" },
    { "option": "-crf", "argument": "28" },
    { "option": "-preset", "argument": "medium" }
  ]
}

Trim a section:

Trim this video from 5 seconds to 15 seconds:
https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4

Stitch multiple videos together:

Concatenate these two videos into one MP4:
1. https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4
2. https://www.ffmpeg-micro.com/samples/quickstart-sample.mp4

Every operation goes through the same flow: natural language in, processed video out.

Step 5: Build a System Prompt for Your Agent

If you're building this into a product, give Claude a system prompt that constrains the agent to video operations:

You are a video editing assistant. You have access to the FFmpeg Micro
MCP server for video processing. When a user describes a video edit:

1. Identify the operation (transcode, trim, compress, extract audio, etc.)
2. Use the transcode_and_wait tool with the correct parameters
3. Return the download URL to the user
4. If the job fails, explain what went wrong

Always use preset mode for simple operations (quality + resolution).
Use options mode for specific codecs, filters, or advanced FFmpeg flags.
Never ask the user for technical parameters — infer them from the request.

This turns Claude from a general-purpose assistant into a focused video editing agent that handles the technical details automatically.

Common Pitfalls

Using a non-public video URL. The FFmpeg Micro API needs to fetch your video. If the URL requires authentication or is behind a firewall, the job will fail. For private files, use the upload flow first (presigned URL, PUT, confirm) to get a cloud storage URL.

Forgetting to check job status. If you use transcode_video instead of transcode_and_wait, the job runs asynchronously. You'll need to call get_transcode to check when it's done. For agent workflows, transcode_and_wait avoids this entirely.

Asking for unsupported output formats. The API supports mp4, webm, avi, mov, mkv, gif, mp3, wav, and more. But if you ask Claude to output a format that FFmpeg doesn't support for your input, the job will fail with a clear error message.

Why This Approach Beats Shell Scripts

The traditional way to automate video editing with AI is prompting for FFmpeg commands, then running them locally. That works, but it has problems:

You need FFmpeg installed on every machine
Complex operations need multiple commands chained together
Error handling is on you (wrong codecs, missing dependencies, file permission issues)
Scaling means provisioning and managing servers

With the MCP agent approach, Claude handles the complexity and FFmpeg Micro handles the infrastructure. Your code (or your users) just describes what they want in plain English.

FFmpeg Micro processes over 50,000 API calls per month. A 1-minute video transcode takes about 3 seconds. Pricing starts with a free tier, so you can prototype without spending anything.

FAQ

Can I use this with GPT-4 or other LLMs instead of Claude?

The MCP protocol is currently supported by Claude Desktop, Claude Code, Cursor, Windsurf, and other MCP-compatible tools. For OpenAI or other providers, you'd call the FFmpeg Micro REST API directly instead of going through MCP. The API itself works with any HTTP client.

Do I need to know FFmpeg commands to use this?

No. That's the point. The agent translates natural language to the right API calls. You say "compress this video" and Claude figures out the codec, CRF, and preset. If you do know FFmpeg, you can be more specific ("use libx265 with CRF 24"), and the agent will use those exact settings.

What happens if my video is too large?

FFmpeg Micro supports files up to 2GB. For larger files, you'll need to split them first. The free tier has usage limits. Check ffmpeg-micro.com/pricing for details on each plan.

Can I chain multiple operations in one request?

Each API call handles one operation. But the agent can chain them automatically. Ask Claude "trim this video to 30 seconds, then convert to 720p WebM" and it will run two sequential transcode jobs, using the output of the first as the input for the second.

Is the MCP server open source?

Yes. The FFmpeg Micro MCP server is published as @ffmpeg-micro/mcp-server on npm. You can inspect the source, fork it, or contribute.

How to Use FFmpeg with TypeScript (No Installation Required)

Javid Jamae — Fri, 19 Jun 2026 10:14:49 +0000

Originally published at ffmpeg-micro.com

You need to process video in your TypeScript project. Maybe you're building a Next.js app that generates thumbnails, a Bun server that transcodes user uploads, or an Express API that automates video workflows. You search for "ffmpeg typescript" and find a mess of untyped wrappers, broken binaries, and workarounds.

TypeScript developers deserve type-safe video processing. But most approaches to FFmpeg in the Node.js ecosystem were built for JavaScript first, and the TypeScript experience is an afterthought. There are several paths, each with real tradeoffs.

Using child_process with TypeScript

The lowest-level approach. Install FFmpeg on your system and call it via Node's child_process:

import { spawn } from 'child_process';

const ffmpeg = spawn('ffmpeg', [
  '-i', 'input.mp4',
  '-c:v', 'libx264',
  '-crf', '23',
  '-preset', 'medium',
  '-c:a', 'aac',
  '-b:a', '192k',
  'output.mp4'
]);

ffmpeg.stderr.on('data', (data: Buffer) => {
  console.log(`FFmpeg: ${data.toString()}`);
});

ffmpeg.on('close', (code: number | null) => {
  if (code !== 0) {
    throw new Error(`FFmpeg exited with code ${code}`);
  }
  console.log('Transcoding complete');
});

TypeScript's type annotations give you Buffer and number | null on the callbacks. But that's where the type safety ends. The FFmpeg arguments are just strings. Typo in -c:v? TypeScript won't catch it. Wrong codec name? You'll find out at runtime. And you still need FFmpeg installed on every machine that runs your code.

Using fluent-ffmpeg with TypeScript

fluent-ffmpeg has community-maintained type definitions via @types/fluent-ffmpeg:

import ffmpeg from 'fluent-ffmpeg';

ffmpeg('input.mp4')
  .videoCodec('libx264')
  .audioCodec('aac')
  .size('1280x720')
  .on('end', () => console.log('Done'))
  .on('error', (err: Error) => console.error(err.message))
  .save('output.mp4');

The types cover the chainable API, so you get autocomplete for methods like .videoCodec() and .size(). But the types are community-maintained and frequently lag behind the library. You'll hit any types in edge cases, especially around filters and complex operations. And fluent-ffmpeg still requires a local FFmpeg binary. In Docker deployments, that adds 80-200MB to your image.

ffmpeg.wasm for Browser-Side TypeScript

ffmpeg.wasm compiles FFmpeg to WebAssembly and ships with its own TypeScript types:

import { FFmpeg } from '@ffmpeg/ffmpeg';

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

No binary installation. Runs in the browser or Node.js. But processing is 10-20x slower than native FFmpeg, memory is limited to what the browser tab can allocate, and not all codecs are available in the WASM build. Fine for trimming a 30-second clip. Don't try transcoding a 1GB file.

Cloud API: Type-Safe FFmpeg Without Installing Anything

If you don't want to manage FFmpeg binaries, deal with platform-specific builds, or add hundreds of megabytes to your Docker image, a cloud API is the cleanest path for TypeScript developers.

FFmpeg Micro is a cloud API that lets you process video with a single HTTP call. No FFmpeg installation, no server management, no binary dependencies. And because it's just HTTP, it works with TypeScript's type system naturally.

Here's a fully typed example:

interface TranscodeInput {
  url: string;
}

interface TranscodeRequest {
  inputs: TranscodeInput[];
  outputFormat: string;
  preset?: {
    quality: 'low' | 'medium' | 'high';
    resolution?: '480p' | '720p' | '1080p' | '4k';
  };
  options?: {
    option: string;
    argument: string;
  }[];
}

interface TranscodeResponse {
  id: string;
  status: 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled';
  outputUrl?: string;
  billableMinutes?: number;
}

async function transcodeVideo(
  request: TranscodeRequest
): Promise<TranscodeResponse> {
  const response = await fetch(
    'https://api.ffmpeg-micro.com/v1/transcodes',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.FFMPEG_MICRO_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(request),
    }
  );

  if (!response.ok) {
    throw new Error(`Transcode failed: ${response.statusText}`);
  }

  return response.json();
}

Now you can call it with full type safety:

const result = await transcodeVideo({
  inputs: [{ url: 'https://example.com/video.mp4' }],
  outputFormat: 'mp4',
  preset: { quality: 'high', resolution: '1080p' },
});

console.log(`Job ${result.id} status: ${result.status}`);

The TypeScript compiler catches bad property names, wrong types, and invalid enum values at build time. No runtime surprises from typo'd FFmpeg flags.

Polling for Job Completion

Transcode jobs are async. Here's a type-safe polling function:

async function waitForTranscode(
  jobId: string,
  maxWaitMs = 300000
): Promise<TranscodeResponse> {
  const start = Date.now();

  while (Date.now() - start < maxWaitMs) {
    const response = await fetch(
      `https://api.ffmpeg-micro.com/v1/transcodes/${jobId}`,
      {
        headers: {
          'Authorization': `Bearer ${process.env.FFMPEG_MICRO_API_KEY}`,
        },
      }
    );

    const job: TranscodeResponse = await response.json();

    if (job.status === 'completed' || job.status === 'failed') {
      return job;
    }

    await new Promise((r) => setTimeout(r, 2000));
  }

  throw new Error(`Timed out waiting for job ${jobId}`);
}

Use it after creating a transcode:

const job = await transcodeVideo({
  inputs: [{ url: 'https://example.com/raw-upload.mov' }],
  outputFormat: 'mp4',
  preset: { quality: 'medium' },
});

const completed = await waitForTranscode(job.id);
console.log(`Output ready: ${completed.outputUrl}`);

Advanced: Custom FFmpeg Options with Type Safety

For operations beyond presets (specific codecs, filters, bitrate control), use the options array:

const result = await transcodeVideo({
  inputs: [{ url: 'https://example.com/video.mp4' }],
  outputFormat: 'webm',
  options: [
    { option: '-c:v', argument: 'libvpx-vp9' },
    { option: '-crf', argument: '30' },
    { option: '-b:v', argument: '0' },
    { option: '-c:a', argument: 'libopus' },
  ],
});

The options array accepts any valid FFmpeg flag. You get the full power of FFmpeg's CLI without managing the binary.

Which Approach Should You Use?

It depends on your constraints:

Approach	Type Safety	Requires FFmpeg Install	Best For
child_process	Minimal (callback types only)	Yes	Scripts, CI pipelines
fluent-ffmpeg	Partial (@types lag behind)	Yes	Existing codebases already using it
ffmpeg.wasm	Good (ships own types)	No	Small client-side edits
Cloud API (FFmpeg Micro)	Full (you define the interfaces)	No	Production apps, serverless, Docker

For most TypeScript projects shipping to production, the cloud API approach gives you the best developer experience. No binary to install. No Docker image bloat. No platform-specific builds breaking in CI. Just typed HTTP calls that work the same everywhere your TypeScript runs.

FAQ

Can I use FFmpeg with Deno or Bun in TypeScript?

Yes. Since the cloud API approach uses standard fetch, it works in any TypeScript runtime: Node.js, Deno, Bun, Cloudflare Workers, or even the browser. No runtime-specific dependencies.

Does FFmpeg Micro have an official TypeScript SDK?

Not yet. But since the API is simple REST (POST to create a job, GET to check status), the typed fetch wrapper shown above covers every operation. The OpenAPI spec is available at ffmpeg-micro.com/docs if you want to generate types from it.

How much does cloud video processing cost vs. running FFmpeg locally?

FFmpeg Micro charges per minute of video processed, starting with a free tier. For production workloads, this is typically cheaper than maintaining your own FFmpeg infrastructure when you factor in server costs, DevOps time, and scaling. A 1-minute video transcode takes about 3 seconds via the API.

Can I use FFmpeg Micro with Next.js API routes?

Yes. API routes in Next.js run on the server. Use the typed fetch wrapper from a route handler or server action. No binary installation needed since the processing happens in the cloud, not on your server.

What video formats does the FFmpeg Micro API support?

The API supports all formats FFmpeg supports as input. For output, specify the format in the outputFormat field: mp4, webm, avi, mov, mkv, gif, mp3, wav, and more. See the full docs at ffmpeg-micro.com/docs.

Auto-Publish 30 YouTube Shorts Per Week from One Long Video

Javid Jamae — Thu, 18 Jun 2026 10:20:36 +0000

Originally published at ffmpeg-micro.com

One 30-minute video contains enough material for 30+ YouTube Shorts. Most creators leave that content on the table because splitting, captioning, and publishing 30 clips manually takes hours. With n8n and FFmpeg Micro, you can automate the entire pipeline: split the long video, add captions to each clip, and schedule them for auto-publish.

The Pipeline at a Glance

Split a long video into 30-60 second clips using FFmpeg Micro's trim and crop operations
Caption each clip with burned-in subtitles using Whisper transcription
Publish each captioned clip to YouTube on a schedule via the YouTube Data API

The whole thing runs in n8n, triggered by dropping a video URL into a webhook or a Google Drive folder.

Step 1: Split the Long Video into Clips

Use FFmpeg Micro's transcription endpoint to generate an SRT file and identify natural break points:

curl -X POST https://api.ffmpeg-micro.com/v1/transcribe \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"media_url": "https://storage.googleapis.com/your-bucket/long-video.mp4"}'

Then trim each clip:

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.googleapis.com/your-bucket/long-video.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-ss", "argument": "00:02:15"},
      {"option": "-t", "argument": "45"},
      {"option": "-vf", "argument": "crop=ih*9/16:ih"},
      {"option": "-c:v", "argument": "libx264"},
      {"option": "-preset", "argument": "fast"}
    ]
  }'

One API call per clip. 45 seconds, 9:16 vertical, H.264.

Step 2: Add Captions

Transcribe each clip individually, then burn subtitles back in with FFmpeg Micro's text overlay.

Step 3: The n8n Workflow

Six nodes: Webhook trigger, HTTP Request (transcribe), Wait (poll), Code (parse SRT), Loop (trim+caption each clip), YouTube upload (scheduled publish).

const totalDuration = $input.first().json.duration;
const CLIP_DURATION = 45;
const segments = [];

for (let i = 0; i < Math.floor(totalDuration / CLIP_DURATION); i++) {
  const startSeconds = i * CLIP_DURATION;
  const hours = String(Math.floor(startSeconds / 3600)).padStart(2, '0');
  const mins = String(Math.floor((startSeconds % 3600) / 60)).padStart(2, '0');
  const secs = String(startSeconds % 60).padStart(2, '0');
  segments.push({
    clipNumber: i + 1,
    startTime: `${hours}:${mins}:${secs}`,
    duration: CLIP_DURATION
  });
}
return segments.map(s => ({ json: s }));

Cost Breakdown

For a 30-minute source video producing 30 clips: ~96 billable minutes total. One video per month fits in FFmpeg Micro's free tier (100 min/mo). Weekly production needs the Pro plan at $19/month.

FAQ

How many YouTube Shorts can I make from a 30-minute video?
30-40 Shorts at 45-60 seconds each.

Do I need to install FFmpeg?
No. FFmpeg Micro is a cloud API. HTTP requests from n8n handle everything.

Can I use Make.com instead of n8n?
Yes. FFmpeg Micro has an official Make.com app.

FFmpeg Scale Filter: Resize Video and Keep Aspect Ratio

Javid Jamae — Thu, 18 Jun 2026 10:19:51 +0000

Originally published at ffmpeg-micro.com

You need to resize a video to 1080p, but the input is 4:3 and the output needs to be 16:9. You use -s 1920x1080 and get a stretched, distorted mess. The fix is FFmpeg's scale filter, and specifically, the -2 trick and force_original_aspect_ratio flag.

This guide covers every common scaling scenario: auto-calculation with -2, forced aspect ratios, letterboxing with pad, and how to do it all through an API instead of wrestling with CLI flags.

Quick Answer: Scale Without Distortion

The fastest way to resize a video while keeping its aspect ratio intact:

ffmpeg -i input.mp4 -vf "scale=-2:1080" output.mp4

The -2 tells FFmpeg to calculate the width automatically based on the input's aspect ratio, rounding to the nearest even number (which video codecs require). Your 4:3 input becomes 1440x1080. Your 16:9 input becomes 1920x1080. No distortion.

What the -2 Value Actually Does

FFmpeg's scale filter takes width and height as arguments: scale=width:height. When you set either dimension to -1 or -2, FFmpeg calculates that dimension from the other one using the original aspect ratio.

The difference between -1 and -2:

-1 calculates the value, but it might produce an odd number (e.g., 1441)
-2 does the same calculation but rounds to the nearest even number

Odd pixel dimensions cause encoding failures with H.264 and H.265. Always use -2, not -1.

# Scale to 720p height, auto-calculate width
ffmpeg -i input.mp4 -vf "scale=-2:720" output.mp4

# Scale to 1280 width, auto-calculate height
ffmpeg -i input.mp4 -vf "scale=1280:-2" output.mp4

# Scale to 4K height
ffmpeg -i input.mp4 -vf "scale=-2:2160" output.mp4

force_original_aspect_ratio: Fit or Fill

Sometimes you need the output to be exactly 1920x1080, no exceptions. But your input is 4:3. The force_original_aspect_ratio parameter handles this without stretching.

decrease shrinks the video to fit inside the target dimensions:

ffmpeg -i input.mp4 -vf "scale=1920:1080:force_original_aspect_ratio=decrease" output.mp4

increase enlarges the video to fill the target dimensions:

ffmpeg -i input.mp4 -vf "scale=1920:1080:force_original_aspect_ratio=increase" output.mp4

Letterboxing with pad

If you need exactly 1920x1080 with black bars (letterboxing), chain the pad filter:

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

Common Resolution Targets

Target	Command
480p (SD)	`scale=-2:480`
720p (HD)	`scale=-2:720`
1080p (Full HD)	`scale=-2:1080`
2160p (4K)	`scale=-2:2160`

Scale via the FFmpeg Micro API

If you don't want to install FFmpeg or manage a server, you can resize videos through an API call:

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/video.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-vf", "argument": "scale=-2:1080"}
    ]
  }'

FFmpeg Micro is a cloud API that accepts the same FFmpeg filters as the CLI. No FFmpeg installation, no server management.

FAQ

Does ffmpeg scale preserve aspect ratio by default?
No. The default scale=width:height stretches the video to fit both dimensions. Use -2 for auto-calculation or force_original_aspect_ratio to prevent distortion.

What's the difference between -s and -vf scale in FFmpeg?
-s 1920x1080 sets exact output dimensions and can distort. -vf "scale=-2:1080" calculates one dimension from the other to keep the aspect ratio.

Can I resize video through an API without installing FFmpeg?
Yes. FFmpeg Micro is a cloud API that accepts the same FFmpeg filters. Send a POST to /v1/transcodes with options: [{"option": "-vf", "argument": "scale=-2:1080"}] and get back the resized video.