DEV Community: Javid Jamae

Auto-Add Captions to Every Video Your Team Uploads (n8n + FFmpeg)

Javid Jamae — Fri, 12 Jun 2026 10:15:42 +0000

Originally published at ffmpeg-micro.com

Every video your team publishes needs captions. Accessibility requirements, social media autoplay, SEO value. But nobody wants to sit there adding subtitles by hand, and outsourcing transcription adds days of turnaround.

You can automate the entire thing. This n8n workflow watches a folder (Google Drive, Dropbox, or an S3 bucket), transcribes new videos with FFmpeg Micro's Whisper-based API, burns the captions directly into the video, and drops the result wherever you need it. Your team uploads a video. A few minutes later, the captioned version appears. No manual steps.

What you're building

The workflow has four stages:

Trigger: n8n watches for new video files in a cloud folder
Transcribe: FFmpeg Micro generates an SRT subtitle file from the audio track
Burn captions: A second FFmpeg Micro call overlays the SRT onto the video
Deliver: The captioned video gets saved back to your storage or sent to Slack

Each step is a single HTTP request. No FFmpeg installed anywhere. No GPU instances. No transcription service accounts.

Prerequisites

You'll need an n8n instance (cloud or self-hosted), an FFmpeg Micro API key from ffmpeg-micro.com, and a cloud storage folder your team already uses for video files.

Step 1: Set up the trigger

In n8n, create a new workflow and add a trigger node for your storage provider. Google Drive and Dropbox both have native trigger nodes. For S3, use the Schedule Trigger and check for new objects.

The trigger should fire when a new video file lands in a specific folder. Filter for video MIME types (video/mp4, video/quicktime, video/webm) so you don't accidentally process PDFs.

Step 2: Transcribe the audio to SRT

Add an HTTP Request node that calls FFmpeg Micro's transcribe endpoint. This uses Whisper under the hood to generate an SRT subtitle file from the video's audio track.

{
  "method": "POST",
  "url": "https://api.ffmpeg-micro.com/v1/transcribe",
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "media_url": "{{ $json.fileUrl }}",
    "language": "en"
  }
}

The media_url field accepts any public URL. If your storage provides signed URLs (like S3 presigned URLs or Supabase signed URLs), those work too. The language field is optional. Leave it out and Whisper will auto-detect.

This returns a job with status: "queued". You need to poll until it's done.

Step 3: Poll until transcription completes

Add a loop that checks the transcribe job status every 3 seconds. In n8n, use an HTTP Request node inside a Loop Over Items node, or use a Wait node with a loop-back connection.

The simplest pattern:

HTTP Request to GET https://api.ffmpeg-micro.com/v1/transcribe/{{ $json.id }}
IF node checking {{ $json.status }} equals completed
If not completed, Wait 3 seconds and loop back to the GET request
If completed, continue to the next step

Once the status is completed, grab the SRT download URL:

{
  "method": "GET",
  "url": "https://api.ffmpeg-micro.com/v1/transcribe/{{ $json.id }}/download",
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY"
  }
}

This returns a signed URL for the SRT file that's valid for 10 minutes. You don't need to download the SRT yourself. Just pass the URL to the next step.

Step 4: Burn captions into the video

Now you have two URLs: the original video and the generated SRT file. Send both to FFmpeg Micro's transcode endpoint to burn the subtitles directly into the video.

{
  "method": "POST",
  "url": "https://api.ffmpeg-micro.com/v1/transcodes",
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "inputs": [{ "url": "{{ $json.originalVideoUrl }}" }],
    "outputFormat": "mp4",
    "options": [
      { "option": "-vf", "argument": "subtitles={{ $json.srtUrl }}" }
    ]
  }
}

The -vf subtitles= filter burns the SRT text onto every frame. The captions become part of the video itself, so they show up everywhere, not just players that support SRT tracks.

Poll this job the same way you polled the transcribe job. When it's completed, grab the download URL from /v1/transcodes/{id}/download.

Step 5: Save the captioned video

The final step depends on where your team wants the output. Common options:

Google Drive: Use n8n's Google Drive node to upload the file to a "Captioned" subfolder.

Slack notification: Post the download URL to a channel so the team knows it's ready.

S3/Supabase: Upload to your storage bucket with a predictable naming convention like captioned-{original-filename}.mp4.

Add an HTTP Request node to download the processed video from the FFmpeg Micro signed URL, then pipe it to your output node.

The complete n8n workflow

The finished workflow, node by node:

Google Drive Trigger (new file in /Team Videos/)
HTTP Request: POST /v1/transcribe (start transcription)
Loop: Poll GET /v1/transcribe/{id} until completed
HTTP Request: GET /v1/transcribe/{id}/download (get SRT URL)
HTTP Request: POST /v1/transcodes (burn captions)
Loop: Poll GET /v1/transcodes/{id} until completed
HTTP Request: GET /v1/transcodes/{id}/download (get final video)
Google Drive Upload: Save to /Team Videos/Captioned/

Total: 8 nodes, zero code, runs automatically.

Common pitfalls

The SRT download URL expires in 10 minutes. Don't add a long delay between the transcribe download and the transcode request. The signed URL from /v1/transcribe/{id}/download has a 10-minute window. If you're processing long videos, start the transcode immediately after getting the SRT URL.

Public URLs only. FFmpeg Micro needs to download your video file. If your Google Drive or Dropbox file isn't publicly accessible, you'll need to generate a sharing link or use a signed URL. Most n8n storage nodes can output a public download URL.

Caption styling is default. The basic subtitles= filter uses FFmpeg's default white-text-with-black-outline style. If you want custom fonts, colors, or positioning, you'll need to pass additional FFmpeg filter options. Check the FFmpeg subtitles filter documentation for styling parameters.

Language detection isn't perfect. If your team records in a specific language, set the language field explicitly in the transcribe request instead of relying on auto-detection. Auto-detect works well for common languages but can struggle with code-switching or heavy accents.

FAQ

How accurate is the transcription?
FFmpeg Micro uses Whisper for transcription, which handles English and most European languages very well. For clean audio with a single speaker, expect 95%+ accuracy. Background noise, multiple speakers, or heavy accents will reduce accuracy.

Can I process videos longer than 10 minutes?
Yes. FFmpeg Micro handles videos of any reasonable length. Transcription time scales roughly linearly with audio duration. A 10-minute video typically takes 1-2 minutes to transcribe. Billing is per minute of input media.

What about non-English content?
Set the language field to the appropriate BCP-47 code (like "es" for Spanish or "fr" for French). You can also use "task": "translate" to transcribe foreign-language audio and output the subtitles in English.

Does this work with n8n Cloud?
Yes. Everything runs through HTTP requests to the FFmpeg Micro API. No Execute Command nodes, no local FFmpeg binaries. n8n Cloud handles it just fine.

What does this cost per video?
Two FFmpeg Micro API calls per video: one for transcription, one for burning captions. Both bill per minute of input. A 5-minute video costs roughly the equivalent of 10 minutes of processing. On the free tier, that's enough to test the workflow. Production pricing starts at $19/month.

Add Video Processing to Your Vercel + Supabase App in 10 Minutes

Javid Jamae — Fri, 12 Jun 2026 10:15:28 +0000

Originally published at ffmpeg-micro.com

Most Vercel + Supabase apps hit the same wall: a user uploads a video, and you need to do something with it. Compress it, convert it, extract a thumbnail. You Google "ffmpeg vercel" and realize serverless functions time out after 60 seconds, and video processing takes way longer than that.

You don't need to spin up a separate server. FFmpeg Micro is a cloud API that processes video with a single HTTP call. It fits into the Vercel + Supabase stack without any infrastructure changes.

This guide walks through the full flow: upload to Supabase Storage, process with FFmpeg Micro, and store the result back in Supabase. You can have it running in under 10 minutes.

Why you can't just run FFmpeg in a Vercel function

Vercel Serverless Functions have a 60-second timeout on the Pro plan (10 seconds on Hobby). A 30-second video transcode can take 2-3 minutes depending on the codec and resolution. Even if you could fit it in the timeout, the function would burn compute the entire time.

FFmpeg Micro handles the processing asynchronously. You send a request, get a job ID, and poll or use a webhook to know when it's done. Your Vercel function stays fast because it's only making HTTP calls, not running FFmpeg binaries.

The architecture (3 pieces)

Your app needs three things:

Supabase Storage for file uploads and final output storage
FFmpeg Micro API for the actual video processing
A Vercel API route (or Edge Function) that ties them together

The flow looks like this: user uploads a video to Supabase Storage, your API route sends the public URL to FFmpeg Micro, FFmpeg Micro processes it and returns a download URL, and your app saves the result back to Supabase.

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 everything in this guide.

Step 2: Set up the environment variables

Add these to your Vercel project (or .env.local for local dev):

FFMPEG_MICRO_API_KEY=your_api_key_here
NEXT_PUBLIC_SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_ROLE_KEY=your_service_role_key

Step 3: Create the transcode API route

This is a Next.js API route that accepts a Supabase Storage URL and sends it to FFmpeg Micro for processing.

// app/api/transcode/route.ts
import { NextRequest, NextResponse } from "next/server";

export async function POST(req: NextRequest) {
  const { videoUrl, outputFormat } = await req.json();

  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({
      inputs: [{ url: videoUrl }],
      outputFormat: outputFormat || "mp4",
      preset: { quality: "medium", resolution: "720p" },
    }),
  });

  const job = await response.json();
  return NextResponse.json({ jobId: job.id, status: job.status });
}

The inputs array takes objects with a url field. You can pass a public Supabase Storage URL directly. The preset field sets quality and resolution without needing to know FFmpeg flags.

Step 4: Poll for completion

FFmpeg Micro processes video asynchronously. You need to check the job status until it's completed.

// lib/ffmpeg-micro.ts
export async function pollTranscode(jobId: string): Promise<string> {
  const maxAttempts = 30;

  for (let i = 0; i < maxAttempts; i++) {
    const res = await fetch(
      `https://api.ffmpeg-micro.com/v1/transcodes/${jobId}`,
      {
        headers: {
          Authorization: `Bearer ${process.env.FFMPEG_MICRO_API_KEY}`,
        },
      }
    );

    const job = await res.json();

    if (job.status === "completed") {
      const dlRes = await fetch(
        `https://api.ffmpeg-micro.com/v1/transcodes/${jobId}/download`,
        {
          headers: {
            Authorization: `Bearer ${process.env.FFMPEG_MICRO_API_KEY}`,
          },
        }
      );
      const { url } = await dlRes.json();
      return url;
    }

    if (job.status === "failed") {
      throw new Error(`Transcode failed: ${job.error_message}`);
    }

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

  throw new Error("Transcode timed out");
}

Step 5: Save the result back to Supabase

Once you have the download URL from FFmpeg Micro, fetch the processed video and upload it to your Supabase Storage bucket.

// lib/save-to-supabase.ts
import { createClient } from "@supabase/supabase-js";

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
);

export async function saveProcessedVideo(
  downloadUrl: string,
  outputPath: string
) {
  const videoResponse = await fetch(downloadUrl);
  const videoBuffer = await videoResponse.arrayBuffer();

  const { data, error } = await supabase.storage
    .from("videos")
    .upload(outputPath, videoBuffer, {
      contentType: "video/mp4",
      upsert: true,
    });

  if (error) throw error;

  const {
    data: { publicUrl },
  } = supabase.storage.from("videos").getPublicUrl(outputPath);

  return publicUrl;
}

Putting it together

The full flow in one API route:

// app/api/process-video/route.ts
import { NextRequest, NextResponse } from "next/server";
import { pollTranscode } from "@/lib/ffmpeg-micro";
import { saveProcessedVideo } from "@/lib/save-to-supabase";

export async function POST(req: NextRequest) {
  const { videoUrl, outputFormat } = await req.json();

  // 1. Start the transcode
  const createRes = 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({
        inputs: [{ url: videoUrl }],
        outputFormat: outputFormat || "mp4",
        preset: { quality: "medium", resolution: "720p" },
      }),
    }
  );

  const job = await createRes.json();

  // 2. Wait for processing to finish
  const downloadUrl = await pollTranscode(job.id);

  // 3. Save to Supabase Storage
  const outputPath = `processed/${Date.now()}-output.${outputFormat || "mp4"}`;
  const publicUrl = await saveProcessedVideo(downloadUrl, outputPath);

  return NextResponse.json({ publicUrl, jobId: job.id });
}

Advanced: use raw FFmpeg options

The preset mode covers common cases. But if you need something specific, like extracting audio or adding a watermark, you can pass raw FFmpeg options instead:

{
  "inputs": [{ "url": "https://your-supabase-url.co/storage/v1/object/public/videos/input.mp4" }],
  "outputFormat": "mp4",
  "options": [
    { "option": "-c:v", "argument": "libx264" },
    { "option": "-crf", "argument": "23" },
    { "option": "-c:a", "argument": "aac" }
  ]
}

This gives you the full flexibility of FFmpeg without having to install or manage it.

Common pitfalls

Supabase Storage URLs must be public (or signed). FFmpeg Micro needs to download your video. Either make the bucket public or generate a signed URL with a long enough expiry (the processing can take a few minutes).

Don't poll from the client. Run the poll loop server-side in your API route or use a background job. Client-side polling ties up a browser tab and exposes your API key.

Watch your function timeout. The polling loop above can run for up to 60 seconds. On Vercel Pro, that's fine for Serverless Functions. On the Hobby plan, consider using a webhook callback instead of polling.

Use outputFormat not format. The FFmpeg Micro API uses outputFormat in the request body. If you pass format, it'll be silently ignored and you'll get unexpected defaults.

FAQ

Can I use this with the Vercel Hobby plan?
Yes, but the 10-second function timeout means you can't poll inline. Use a webhook callback or process the video client-side by calling FFmpeg Micro directly from the browser (your API key should stay server-side, so you'd need a thin proxy route).

Does FFmpeg Micro support webhooks?
Not yet as a built-in feature, but you can build your own callback by storing the job ID in your database and running a cron job or background function to check status.

What video formats does FFmpeg Micro accept?
MP4, WebM, MOV, AVI, and MKV for input. Output formats are MP4, WebM, and MOV. Most Supabase apps deal with MP4, which works perfectly.

How much does it cost?
FFmpeg Micro bills per minute of video processed. The free tier includes enough for testing. For production, pricing starts at $19/month. Check ffmpeg-micro.com/pricing for current rates.

Can I process multiple videos in parallel?
Yes. Each API call is independent. Fire off multiple transcode requests and poll them separately. FFmpeg Micro handles the scaling.

Build a YouTube to TikTok Auto-Repost Pipeline (n8n + FFmpeg)

Javid Jamae — Thu, 11 Jun 2026 10:19:37 +0000

Originally published at ffmpeg-micro.com.

You post a YouTube video. Then you download it, crop it to vertical, and manually upload to TikTok. Every single time.

If you're posting three times a week, that's an hour of drag-and-drop work that adds zero creative value. The video already exists. You just need it in a different shape.

This guide builds an n8n workflow that watches your YouTube channel, crops new videos to 9:16 vertical format using the FFmpeg Micro API, and delivers them ready for TikTok. The whole thing runs hands-free once it's set up.

What You're Building

The pipeline has four stages:

n8n watches your YouTube channel for new uploads
The workflow grabs the video URL
FFmpeg Micro crops it to 9:16 vertical (1080x1920)
The output goes to Google Drive or directly to TikTok

Each stage is one node in n8n. Total setup time: about 30 minutes.

Step 1: YouTube Trigger

In n8n, add an RSS Feed Read node pointed at your YouTube channel's RSS feed:

https://www.youtube.com/feeds/videos.xml?channel_id=YOUR_CHANNEL_ID

Set the polling interval to every 15 minutes. When a new video appears, this node fires and passes the video metadata downstream.

n8n doesn't have a native "YouTube upload" trigger, but the RSS feed is reliable and doesn't require OAuth or API credentials.

Step 2: Get the Video URL

The RSS feed gives you the YouTube watch URL, not a direct download link. You need the actual video file URL to send to FFmpeg Micro.

If your videos are already stored somewhere accessible (Google Drive, S3, or any public URL), use that URL directly and skip this step. This is the simplest path.

For YouTube-hosted videos, use a download service or self-hosted tool like yt-dlp running on your server. The output is a direct video URL that gets passed to the next node.

Step 3: Crop to Vertical with FFmpeg Micro

This is the core transformation. Add an HTTP Request node in n8n:

Method: POST
URL: https://api.ffmpeg-micro.com/v1/transcodes
Authentication: Header Auth, name Authorization, value Bearer YOUR_API_KEY
Body (JSON):

{
  "inputs": [{ "url": "{{ $json.videoUrl }}" }],
  "outputFormat": "mp4",
  "options": [
    { "option": "-vf", "argument": "crop=ih*9/16:ih,scale=1080:1920" },
    { "option": "-c:a", "argument": "copy" }
  ]
}

The -vf crop=ih*9/16:ih,scale=1080:1920 filter does two things. First, it center-crops the frame to a 9:16 aspect ratio by calculating the width as ih*9/16 (input height times 9/16) and keeping the full height. Then it scales the result to exactly 1080x1920 pixels.

Audio stays untouched with -c:a copy. No re-encoding, no quality loss on the audio track.

FFmpeg Micro processes the video in the cloud and returns a job ID immediately. You don't wait for processing to finish in this node.

Step 4: Poll Until Complete

Transcode jobs are async. Add a loop in n8n to check when the job finishes.

Use a Wait node set to 10 seconds, followed by an HTTP Request node:

GET https://api.ffmpeg-micro.com/v1/transcodes/{{ $json.id }}

Wire an IF node after the status check: if status is not completed, loop back to the Wait node. When it's done, move forward.

Then fetch the download URL:

GET https://api.ffmpeg-micro.com/v1/transcodes/{{ $json.id }}/download

This returns a signed HTTPS URL valid for 10 minutes. Download the file in the next node before the link expires.

Step 5: Save or Publish

You now have a cropped, vertical MP4. Where it goes depends on your workflow:

Google Drive (recommended for most creators). Add a Google Drive upload node to drop the file into a "TikTok Ready" folder. Review the video, add captions and hashtags, then post from your phone.

Direct TikTok API. Use TikTok's Content Posting API to upload automatically. This requires a TikTok developer account and approved app. Add an HTTP Request node pointed at TikTok's upload endpoint with the video file.

Most solo creators start with Google Drive. It adds one manual step but gives you a chance to review before publishing.

Customizing the Crop

Center-crop works great for talking-head content where the speaker fills the middle of the frame. For other content types, adjust the filter:

Left-aligned crop (keep the left side of the frame):

{ "option": "-vf", "argument": "crop=ih*9/16:ih:0:0,scale=1080:1920" }

Right-aligned crop (keep the right side):

{ "option": "-vf", "argument": "crop=ih*9/16:ih:iw-ih*9/16:0,scale=1080:1920" }

Padding instead of cropping (adds black bars, keeps all content):

{ "option": "-vf", "argument": "scale=1080:-2,pad=1080:1920:(ow-iw)/2:(oh-ih)/2" }

Talking head content = center crop. Screen recordings = padding. B-roll = test a few options and see what looks best.

Why This Pipeline Works

The YouTube to TikTok repost is one of the highest-leverage automations for solo creators. You already made the content. Cross-posting is distribution, not creation. The only thing stopping most people is the manual crop-and-upload friction.

n8n Cloud can't run FFmpeg directly, but it doesn't need to. The video processing happens on FFmpeg Micro's infrastructure. n8n just sends HTTP requests and orchestrates the flow. This works on both n8n Cloud and self-hosted n8n.

FFmpeg Micro is a cloud API that lets you add video processing to any app with a single HTTP call. No FFmpeg installation, no server management. Get a free API key and build this pipeline in under an hour.

FAQ

Can I use this for Instagram Reels and YouTube Shorts too?

Yes. The 9:16 vertical format at 1080x1920 is the standard for TikTok, Instagram Reels, and YouTube Shorts. Add more output nodes in your n8n workflow to deliver the same cropped video to multiple platforms.

How long does the crop take?

A 10-minute landscape video typically processes in 15 to 30 seconds. FFmpeg Micro auto-scales, so processing time stays consistent regardless of how many jobs you run in parallel.

What if my video is longer than 10 minutes?

FFmpeg Micro handles videos of any length. Longer videos take proportionally longer to process and use more API minutes. If you only want a clip, add -ss (start time) and -t (duration) options alongside the crop filter to trim and crop in a single pass.

Does n8n Cloud support this workflow?

Yes. n8n Cloud handles the orchestration (triggers, HTTP requests, logic). FFmpeg Micro handles the video processing in its own cloud. No binary installs or server access needed on the n8n side.

Do I need a TikTok developer account?

Only for automated posting. If you save to Google Drive and post manually from your phone, no TikTok credentials are needed. Most creators prefer the manual review step anyway since it lets them customize captions and hashtags per platform.

FFmpeg in Make.com: 7 Scenarios That Don't Require Self-Hosting

Javid Jamae — Thu, 11 Jun 2026 10:19:28 +0000

Originally published at ffmpeg-micro.com.

Make.com doesn't have a native FFmpeg module. If you've searched the app directory for one, you already know. But you can still run any FFmpeg operation from a Make.com scenario using the HTTP module and a cloud FFmpeg API.

No Docker container. No server. No binary to install. One HTTP request with a JSON body, and your video gets processed in the cloud.

FFmpeg Micro is a cloud API that lets you add video processing to any app with a single HTTP call. No FFmpeg installation, no server management. All you need in Make.com is the HTTP module.

Setup: The HTTP Module

Every scenario below uses the same HTTP "Make a Request" module. Configure it once:

URL: https://api.ffmpeg-micro.com/v1/transcodes
Method: POST
Headers: Authorization: Bearer YOUR_API_KEY and Content-Type: application/json
Body type: Raw JSON

Get a free API key at ffmpeg-micro.com. The JSON body changes per scenario. The module config stays the same.

1. Convert Customer Uploads to Web-Ready MP4

Users upload MOV files from iPhones. Your web player only handles MP4.

{
  "inputs": [{ "url": "https://your-bucket.s3.amazonaws.com/upload.mov" }],
  "outputFormat": "mp4",
  "preset": {
    "quality": "high",
    "resolution": "1080p"
  }
}

The preset mode handles codec and quality for you. No FFmpeg flags required.

2. Trim Clips for Landing Pages

You have raw interview footage. You need a 15-second highlight for your homepage.

{
  "inputs": [{ "url": "https://your-storage.com/interview.mp4" }],
  "outputFormat": "mp4",
  "options": [
    { "option": "-ss", "argument": "00:02:15" },
    { "option": "-t", "argument": "15" }
  ]
}

This grabs 15 seconds starting at the 2:15 mark. The output is a clean, re-encoded MP4 ready for your site.

3. Create Vertical Shorts from Landscape Video

One horizontal video, cropped to 9:16 for TikTok, Instagram Reels, and YouTube Shorts.

{
  "inputs": [{ "url": "https://your-storage.com/landscape.mp4" }],
  "outputFormat": "mp4",
  "options": [
    { "option": "-vf", "argument": "crop=ih*9/16:ih,scale=1080:1920" }
  ]
}

The crop math (ih*9/16:ih) takes the center of the frame and drops the sides. scale=1080:1920 outputs at standard vertical resolution.

4. Compress Old Video Archives

Your Google Drive is full of uncompressed screen recordings eating storage. Compress them without visible quality loss.

{
  "inputs": [{ "url": "https://your-storage.com/raw-recording.mp4" }],
  "outputFormat": "mp4",
  "options": [
    { "option": "-c:v", "argument": "libx264" },
    { "option": "-crf", "argument": "23" },
    { "option": "-preset", "argument": "slow" },
    { "option": "-c:a", "argument": "copy" }
  ]
}

CRF 23 is visually lossless for most content. The slow preset squeezes more compression at the cost of processing time. Audio stays untouched with -c:a copy.

5. Add Text Branding to Every Video

Your marketing team publishes 20 videos a week. Every one needs the company name burned into the frame.

{
  "inputs": [{ "url": "https://your-storage.com/raw-video.mp4" }],
  "outputFormat": "mp4",
  "options": [
    {
      "option": "@text-overlay",
      "argument": {
        "text": "Your Company Name",
        "style": {
          "fontSize": 36,
          "x": "W-tw-20",
          "y": "H-th-20",
          "boxBorderW": 8
        }
      }
    }
  ]
}

The @text-overlay virtual option handles font rendering, word wrap, and positioning. No drawtext filter syntax to wrestle with.

6. Stitch Multiple Clips Into One Highlight Reel

Three separate clips from a product demo. You need them joined into a single video for your sales deck.

{
  "inputs": [
    { "url": "https://your-storage.com/clip-1.mp4" },
    { "url": "https://your-storage.com/clip-2.mp4" },
    { "url": "https://your-storage.com/clip-3.mp4" }
  ],
  "outputFormat": "mp4",
  "preset": {
    "quality": "high"
  }
}

Pass multiple URLs in the inputs array. FFmpeg Micro concatenates them in order and re-encodes to a consistent output format.

7. Transcode to WebM for Web Delivery

Your site uses the <video> tag with WebM as the primary source. VP9 delivers smaller files than H.264 at the same visual quality.

{
  "inputs": [{ "url": "https://your-storage.com/source.mp4" }],
  "outputFormat": "webm",
  "options": [
    { "option": "-c:v", "argument": "libvpx-vp9" },
    { "option": "-crf", "argument": "30" },
    { "option": "-b:v", "argument": "0" }
  ]
}

VP9 with CRF 30 produces great quality at roughly half the file size of H.264. Setting -b:v 0 lets the CRF value fully control quality instead of capping bitrate.

Polling for Results

Every transcode job runs asynchronously. After creating one, poll the status:

GET https://api.ffmpeg-micro.com/v1/transcodes/{id}

When status is completed, grab the download URL:

GET https://api.ffmpeg-micro.com/v1/transcodes/{id}/download

In Make.com, use a "Repeater" module with a delay to poll every 10 seconds until the job finishes.

Get Started

FFmpeg Micro has a free tier with no credit card required. Grab an API key, drop an HTTP module into your next Make.com scenario, and try one of these JSON bodies.

No server. No Docker. No FFmpeg installation. Just an HTTP call.

Get your free API key

FAQ

Does Make.com have a native FFmpeg module?

No. Make.com can't run FFmpeg directly. You need an external API like FFmpeg Micro, which you call through Make.com's HTTP module. One POST request per video operation.

How much does video processing cost in Make.com?

FFmpeg Micro charges per minute of video processed, separate from your Make.com plan. There's a free tier for getting started. Most Make.com workflows process short clips (under 5 minutes each), so costs stay low. See pricing for current rates.

Can I chain multiple FFmpeg operations in one scenario?

Yes. Each FFmpeg Micro API call handles one operation. Chain multiple HTTP modules in your Make.com scenario to run sequential operations. For example: trim first, then compress, then add text. Each step gets its own HTTP module with a different JSON body.

What video formats does FFmpeg Micro support?

Input: MP4, WebM, AVI, MOV, MKV, plus audio formats (MP3, WAV, FLAC, AAC). Output: MP4, WebM, or MOV. Most Make.com workflows use MP4 for both input and output.

How long does processing take?

Most operations complete in 5 to 30 seconds for videos under 10 minutes. Longer videos or compute-heavy encoding (like H.265 with the slow preset) take proportionally longer. FFmpeg Micro scales automatically, so processing time stays consistent regardless of how many jobs you run.

FFmpeg in n8n: 5 Video Automations You Can Ship Today

Javid Jamae — Wed, 10 Jun 2026 16:04:07 +0000

Originally published at ffmpeg-micro.com.

You've connected n8n to your video sources. Maybe it's a Google Drive trigger, a webhook from your CMS, or a scheduled batch job. Now you need to actually do something with those videos. Trim them, resize them, convert formats, add watermarks.

Running FFmpeg locally on your n8n server is one option, but it's fragile and doesn't work on n8n Cloud. Calling a cloud FFmpeg API from the HTTP Request node is simpler and scales without touching your infrastructure.

Here are five video automations you can build in n8n right now using FFmpeg Micro's API. Each one is a single HTTP Request node with a JSON body you can copy and paste.

1. Auto-generate thumbnails from uploaded videos

Every video platform needs thumbnails. Instead of asking users to upload a separate image, extract a frame automatically.

The trick: transcode a single frame at a specific timestamp into an image-friendly format. Use FFmpeg's -ss flag to seek to the right moment and -frames:v 1 to grab exactly one frame.

{
  "inputs": [
    { "url": "https://your-bucket.storage.com/uploaded-video.mp4" }
  ],
  "outputFormat": "mp4",
  "options": [
    { "option": "-ss", "argument": "5" },
    { "option": "-frames:v", "argument": "1" },
    { "option": "-f", "argument": "image2" },
    { "option": "-q:v", "argument": "2" }
  ]
}

POST this to https://api.ffmpeg-micro.com/v1/transcodes with your API key as a Bearer token. Poll GET /v1/transcodes/{id} until status is completed, then grab the output from GET /v1/transcodes/{id}/download.

Wire this into an n8n workflow triggered by a file upload webhook, and every new video gets a thumbnail without anyone lifting a finger.

2. Convert videos to web-friendly MP4

Users upload all kinds of formats. MOV from iPhones, MKV from screen recorders, AVI from legacy tools. Your web player needs MP4 with H.264 video and AAC audio.

{
  "inputs": [
    { "url": "https://your-bucket.storage.com/uploaded-video.mkv" }
  ],
  "outputFormat": "mp4",
  "preset": {
    "quality": "high",
    "resolution": "1080p"
  }
}

The preset approach is the simplest. Set quality to high, medium, or low (maps to FFmpeg CRF values of 18, 23, and 28). Set resolution to cap the output size. Done.

This is the automation most teams build first. Trigger it from a Google Drive watch, an S3 event, or a database row creation. The converted file lands in your output bucket ready for streaming.

3. Batch resize videos for social media

One source video needs to become three: 1080p for YouTube, 720p for Twitter/X, and 480p for mobile fallback. Instead of running three manual conversions, loop through the sizes in n8n.

In your n8n workflow, use a SplitInBatches node feeding into an HTTP Request node. For each resolution, POST:

{
  "inputs": [
    { "url": "https://your-bucket.storage.com/source-video.mp4" }
  ],
  "outputFormat": "mp4",
  "preset": {
    "quality": "medium",
    "resolution": "{{ $json.resolution }}"
  }
}

Set up the SplitInBatches node with three items:

[
  { "resolution": "1080p", "label": "youtube" },
  { "resolution": "720p", "label": "twitter" },
  { "resolution": "480p", "label": "mobile" }
]

Each iteration fires a separate transcode job. n8n handles the orchestration. You end up with three optimized versions from one upload.

4. Add a watermark to client deliverables

Agencies and freelancers: you send preview videos with a watermark, then deliver the clean version after payment. Automate the watermark step so it happens the moment a video is uploaded.

FFmpeg Micro supports the @text-overlay virtual option for text watermarks:

{
  "inputs": [
    { "url": "https://your-bucket.storage.com/client-video.mp4" }
  ],
  "outputFormat": "mp4",
  "options": [
    {
      "option": "@text-overlay",
      "argument": {
        "text": "PREVIEW - youragency.com",
        "style": {
          "fontSize": 36,
          "x": "(w-text_w)/2",
          "y": "(h-text_h)/2",
          "boxBorderW": 8
        }
      }
    }
  ]
}

The x and y expressions center the watermark on the video. boxBorderW adds a background box behind the text so it's readable on any footage. Adjust fontSize to match your video resolution.

Build the n8n workflow: trigger on file upload, run the watermark transcode, save the result alongside the original, notify the team via Slack or email.

5. Compress videos before archiving

Storage costs add up. If you're archiving old project files, user uploads, or training recordings, compress them first. A good H.264 encode at medium quality can cut file size 50-70% with barely noticeable quality loss.

{
  "inputs": [
    { "url": "https://your-bucket.storage.com/archive-video.mp4" }
  ],
  "outputFormat": "mp4",
  "options": [
    { "option": "-c:v", "argument": "libx264" },
    { "option": "-crf", "argument": "28" },
    { "option": "-preset", "argument": "slow" },
    { "option": "-c:a", "argument": "aac" },
    { "option": "-b:a", "argument": "96k" }
  ]
}

CRF 28 is aggressive but perfectly fine for archival video that won't be edited again. The slow preset trades encoding speed for better compression. Audio gets dropped to 96kbps AAC, which is enough for voice-heavy content.

Schedule this as a weekly n8n workflow that scans for videos older than 30 days, compresses them, replaces the originals, and logs the space savings.

The shared setup across all five

Every automation above follows the same pattern:

POST to https://api.ffmpeg-micro.com/v1/transcodes with your JSON body
Poll GET /v1/transcodes/{id} until status is completed
Download via GET /v1/transcodes/{id}/download to get a signed URL

Authentication is a Bearer token in the Authorization header. Set it up once as an n8n credential (Header Auth type) and reuse it across all your video nodes.

The API accepts public URLs as input, so you can pass links from S3, Google Cloud Storage, Cloudflare R2, or any CDN directly. No pre-upload step needed for files that are already publicly accessible.

FAQ

Do I need to install anything on my n8n server?
No. Everything runs through HTTP Request nodes. Works on n8n Cloud and self-hosted installs with zero dependencies.

Can I chain multiple operations?
Not in a single API call (yet). But you can chain them in n8n. Take the output URL from one transcode and use it as the input for the next. Resize first, then add a watermark, for example.

What happens if a job fails mid-workflow?
The transcode status will be failed with an error_message. Add an IF node after your polling loop to check for failures and route to an error handler (Slack notification, email alert, retry logic).

How much does this cost?
FFmpeg Micro bills per minute of video processed. There's a free tier with 10 minutes per month. Enough to test all five automations on short clips. Paid plans scale from there.

Can I process audio files too?
Yes. The API accepts MP3, WAV, FLAC, and AAC. Same endpoint, same workflow. Useful for podcast post-processing, audio normalization, or format conversion.

How to Call FFmpeg from n8n Without the Execute Command Node

Javid Jamae — Wed, 10 Jun 2026 16:03:50 +0000

Originally published at ffmpeg-micro.com.

Most n8n users who want FFmpeg reach for the Execute Command node first. Makes sense. You've got a shell, you know the command, you just want to run ffmpeg -i input.mp4 output.webm and move on.

Then you hit the wall. n8n Cloud doesn't support Execute Command at all. Self-hosted? You need FFmpeg installed on the same machine, and the Execute Command node is a security risk that most production setups lock down. Even when it works, you're stuck managing FFmpeg versions, codecs, and disk space on your n8n server.

There's a better way. Use the HTTP Request node to call an FFmpeg API instead.

Why the Execute Command node breaks in production

The Execute Command node runs arbitrary shell commands on the n8n host machine. For video processing, that means:

n8n Cloud users are locked out. The Execute Command node isn't available on n8n Cloud. If you're on Cloud, you literally can't run FFmpeg this way.
Self-hosted setups need FFmpeg installed. You need to install FFmpeg on the same server, keep it updated, and make sure the right codecs are compiled in.
Security exposure. Any workflow with Execute Command can run any shell command. Most teams disable it in production or restrict it behind environment flags.
Resource contention. Video processing is CPU-heavy. Running FFmpeg on the same machine as n8n means your workflows compete with video jobs for CPU and memory.

None of these problems exist when you call an external API.

The HTTP Request node approach

Instead of running FFmpeg locally, send an HTTP request to a cloud FFmpeg service. The video gets processed on remote infrastructure, and n8n just orchestrates the workflow.

FFmpeg Micro is one such service. One POST request starts a transcode job. You poll for completion, then grab a download link. All through standard HTTP calls that work on n8n Cloud and self-hosted alike.

Step-by-step: convert a video in n8n

Here's the complete setup. Three HTTP Request nodes: start the job, wait for it to finish, get the download URL.

1. Start the transcode job

Add an HTTP Request node with these settings:

Method: POST
URL: https://api.ffmpeg-micro.com/v1/transcodes
Authentication: Predefined Credential Type > Header Auth
- Name: Authorization
- Value: Bearer YOUR_API_KEY
Body Content Type: JSON
JSON Body:

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

The inputs array takes public URLs or GCS URLs from the upload flow. outputFormat accepts mp4, webm, or mov. The preset object handles quality and resolution without writing raw FFmpeg flags.

This returns a job object with an id and status: "queued".

2. Poll until complete

Add a second HTTP Request node inside a loop (or use n8n's Wait node with a 10-second delay):

Method: GET
URL: https://api.ffmpeg-micro.com/v1/transcodes/{{ $json.id }}
Authentication: Same Header Auth credential

The response includes a status field. When it changes from queued to processing to completed, you're done. If it returns failed, the error_message field tells you what went wrong.

A simple approach: add a Wait node (10 seconds), then an IF node that checks {{ $json.status }} != "completed". Loop back to the Wait node if it's still processing.

3. Download the result

Once the job status is completed, grab the signed download URL:

Method: GET
URL: https://api.ffmpeg-micro.com/v1/transcodes/{{ $json.id }}/download
Authentication: Same Header Auth credential

This returns a url field with a signed HTTPS link valid for 10 minutes. Use another HTTP Request node to download the file, or pass the URL to the next step in your workflow (upload to S3, send via email, post to Slack).

Using advanced FFmpeg options

The preset system covers common operations, but you can also pass raw FFmpeg flags through the options array. This is useful for specific codec settings, bitrate control, or audio extraction.

Convert to WebM with a specific CRF value:

{
  "inputs": [
    { "url": "https://example.com/input.mp4" }
  ],
  "outputFormat": "webm",
  "options": [
    { "option": "-c:v", "argument": "libvpx-vp9" },
    { "option": "-crf", "argument": "30" },
    { "option": "-b:v", "argument": "0" }
  ]
}

Extract audio only:

{
  "inputs": [
    { "url": "https://example.com/video.mp4" }
  ],
  "outputFormat": "mp4",
  "options": [
    { "option": "-vn", "argument": "" },
    { "option": "-c:a", "argument": "aac" },
    { "option": "-b:a", "argument": "128k" }
  ]
}

These JSON bodies go straight into the HTTP Request node. No FFmpeg installation, no command-line syntax to debug.

Uploading local files from n8n

If your workflow generates video files (screen recordings, camera uploads, files from other nodes), you need to upload them before transcoding. FFmpeg Micro uses a 3-step upload flow:

Get a presigned URL: POST to /v1/upload/presigned-url with the filename, content type, and file size. The response includes an uploadUrl.
Upload the file: PUT the raw file bytes to the presigned URL. This goes directly to Google Cloud Storage, not through the API server.
Confirm the upload: POST to /v1/upload/confirm with the filename and file size. The response includes a gcsUrl that you pass to the transcode endpoint.

In n8n, each step is one HTTP Request node. The presigned URL upload is fast because n8n streams directly to cloud storage.

Common pitfalls

Using the wrong content type. The transcode endpoint needs Content-Type: application/json. n8n's HTTP Request node sets this automatically when you choose JSON body, but double-check if you're building the request manually.

Forgetting to poll. Transcode jobs are async. The POST request returns immediately with status: "queued". You need the polling loop to know when the output is ready.

Hardcoding the download URL. The signed download URL expires after 10 minutes. Always call the /download endpoint fresh when you need the file. Don't store the signed URL for later use.

Using options and preset together. If you include both in the request body, options takes priority and preset is ignored. Pick one approach per request.

FAQ

Can I use this on n8n Cloud?
Yes. The HTTP Request node works on n8n Cloud with no restrictions. That's the whole point. You don't need Execute Command, and you don't need FFmpeg installed anywhere.

What video formats does the API accept?
MP4, WebM, AVI, QuickTime (MOV), and MKV for video. MP3, WAV, FLAC, and AAC for audio. You can also pass public URLs to files hosted anywhere.

How long does a transcode take?
It depends on file size and complexity. A 1-minute 1080p video typically processes in 10-30 seconds. Longer videos or complex operations (multi-input compositions, H.265 encoding) take proportionally longer.

Is there a free tier?
FFmpeg Micro has a free tier with 10 minutes of processing per month. Enough to test your workflow and process a handful of videos. Paid plans start when you need more volume.

What if the job fails?
The job status changes to failed and the error_message field explains what went wrong. Common causes: unsupported input format, corrupted source file, or incompatible FFmpeg options. Check the error, fix the input, and retry.

FFmpeg Segment Muxer: segment_time, strftime, and reset_timestamps

Javid Jamae — Sat, 30 May 2026 10:18:09 +0000

Originally published at ffmpeg-micro.com

The FFmpeg segment muxer splits a video into multiple files based on duration. Three flags cause most of the confusion: segment_time, strftime, and reset_timestamps. The official FFmpeg docs define each in one sentence. This guide shows what they actually do, with verified examples and the gotchas that trip people up.

Quick answer: Split a video into 5-second segments with timestamped filenames and clean playback timestamps:

ffmpeg -i input.mp4 -c copy -f segment -segment_time 5 -reset_timestamps 1 -strftime 1 "segment_%Y%m%d_%H%M%S.mp4"

What segment_time Does (and Why Your Segments Are the Wrong Length)

segment_time sets the target duration for each segment in seconds. With -c copy (stream copy, no re-encoding), FFmpeg can only cut at keyframe boundaries. If your video has keyframes every 8 seconds and you set -segment_time 3, your segments will be roughly 8 seconds each.

Actual segment durations from a 13-second test video with -segment_time 3 -c copy:

Segment	Expected	Actual
output_000.mp4	~3s	8.34s
output_001.mp4	~3s	5.01s

The muxer waited for the next keyframe after the 3-second mark. Stream copying can't split mid-GOP because there's no re-encoding to create a new keyframe at the cut point.

Fix: force keyframes at your split points. This requires re-encoding:

ffmpeg -i input.mp4 -c:v libx264 -preset ultrafast -crf 23 \
  -force_key_frames "expr:gte(t,n_forced*3)" \
  -f segment -segment_time 3 -reset_timestamps 1 "output_%03d.mp4"

Now the segments are exactly 3 seconds each.

reset_timestamps: Why Your Player Shows the Wrong Time

Without reset_timestamps, each segment inherits its position from the original video. Check with ffprobe: start_time=8.408000. Add -reset_timestamps 1 and it becomes start_time=0.000000.

If you're generating segments for standalone playback, always use -reset_timestamps 1.

strftime: Timestamped Filenames

With -strftime 1, use date/time tokens in the filename: segment_%Y%m%d_%H%M%S.mp4 produces files like segment_20260530_050835.mp4. You can't mix %03d and strftime in the same pattern.

Common Pitfalls

Segments way longer than segment_time: Using -c copy with a GOP interval larger than segment time. Re-encode with -force_key_frames or accept keyframe-aligned cuts.
Player shows black frames: Missing -reset_timestamps 1.
"Could not write header" error: Use -segment_format mp4 explicitly.

FAQ

Does segment_time guarantee exact segment durations?

Only when re-encoding. With -c copy, FFmpeg cuts at the nearest keyframe after the target time.

What's the difference between the segment muxer and HLS muxer?

The HLS muxer (-f hls) is purpose-built for Apple HLS streaming. The segment muxer (-f segment) is a general-purpose splitter. Use HLS muxer for streaming delivery, segment muxer for batch splitting.

Last verified: 2026-05-30 against FFmpeg 4.3

FFmpeg as a Service: Process Video with One API Call

Javid Jamae — Fri, 29 May 2026 10:13:49 +0000

Originally published at ffmpeg-micro.com

You've got FFmpeg running locally. The transcoding works. Then someone asks you to deploy it, and you realize you've signed up for a second job: server admin for a video processing pipeline.

FFmpeg as a service means handing that infrastructure off. You send an HTTP request with your video and the operation you want. You get the processed result back. No FFmpeg binary to install. No server to maintain. No scaling to figure out.

What "FFmpeg as a Service" Actually Means

FFmpeg is the most widely used video processing tool in the world. It handles transcoding, trimming, merging, watermarking, audio extraction, thumbnail generation, and hundreds of other operations. The tool itself isn't the problem. Everything around it is.

Running FFmpeg in production means installing it on a server, managing dependencies across operating systems, building a job queue so processing doesn't block your app, and scaling horizontally when users start uploading more videos than one machine can handle. And patching it when the next security vulnerability drops.

FFmpeg as a service is a cloud API that runs FFmpeg for you. You send a request, it processes the video, you download the result. Services like FFmpeg Micro, Rendi, and ffmpeg-api.com all take this approach, though they differ in how much of FFmpeg's power they actually expose.

Why Developers Keep Building This Themselves

If you've ever shelled out to FFmpeg from application code, you know the pattern:

ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset medium -c:a aac output.mp4

That works on your laptop. Then you deploy and discover:

Your Docker image is 800MB because of FFmpeg dependencies
Processing blocks your event loop or eats your worker pool
A malformed input crashes the process and takes down adjacent services
You need GPU acceleration for H.265 but your cloud instances don't have GPUs
At 200 videos per day, one server can't keep up

Most teams hit this wall somewhere between "it works in development" and "it needs to work in production."

Before and After: Local FFmpeg vs. API Call

Local approach (Node.js subprocess):

import { exec } from 'child_process';

exec(
  'ffmpeg -i /tmp/input.mp4 -c:v libx264 -crf 23 -preset medium /tmp/output.mp4',
  (error, stdout, stderr) => {
    if (error) {
      console.error(stderr);
    }
  }
);

You need FFmpeg installed. You need disk space for temp files. You need to handle crashes, timeouts, and cleanup.

API approach (one HTTP 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/input.mp4"}],
    "outputFormat": "mp4",
    "preset": {
      "quality": "high",
      "resolution": "1080p"
    }
  }'

The response includes a job ID. Poll GET /v1/transcodes/{id} until status is completed, then call GET /v1/transcodes/{id}/download for a signed download URL. No server. No FFmpeg binary. No cleanup.

What About Custom FFmpeg Commands?

Most video processing APIs lock you into preset operations. If you need something outside those presets, you're stuck.

FFmpeg Micro works differently. You can pass raw FFmpeg options directly through the 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://example.com/input.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-c:v", "argument": "libx265"},
      {"option": "-crf", "argument": "28"},
      {"option": "-preset", "argument": "slow"}
    ]
  }'

Same FFmpeg flags you already know. The only difference is who runs the binary.

Common Pitfalls When Switching to a Service

Assuming all APIs expose full FFmpeg. Most don't. AWS MediaConvert, Cloudinary, and Mux give you fixed operation sets. If you need a specific FFmpeg filter or codec combination, you need a service that runs FFmpeg and lets you pass options through.

Ignoring upload time. For large videos, upload can take longer than processing itself. Use presigned URLs for direct-to-storage uploads instead of streaming through your backend.

Expecting synchronous responses. Video processing takes time. A 10-minute video might take 30 to 60 seconds to transcode. Don't build your integration expecting instant results. Poll the job status endpoint or set up webhooks.

Over-engineering at low volume. If you're processing 5 videos a day, a curl call in a cron job is fine. You don't need Kafka and a fleet of workers yet. Start simple.

Frequently Asked Questions

Is FFmpeg as a service the same as a video transcoding API?

Not exactly. A video transcoding API might use FFmpeg internally but only expose a subset of its capabilities through a proprietary interface. FFmpeg as a service gives you FFmpeg itself, accessed through an API. You still use FFmpeg options and flags. The service handles the infrastructure.

Can I use FFmpeg as a service with Make.com, n8n, or Zapier?

Yes. Any platform that makes HTTP requests can call an FFmpeg API. No custom code required.

What video formats does it support?

FFmpeg reads virtually every video and audio format. When using an API, supported output formats depend on the provider. FFmpeg Micro accepts any FFmpeg-readable input and outputs MP4, WebM, or MOV.

Is my video data secure?

Files uploaded to FFmpeg Micro are stored in isolated cloud storage, processed in ephemeral containers, and cleaned up automatically after processing completes. No video data is shared between users or retained beyond the job lifecycle.

How to Create a Video from Images with FFmpeg

Javid Jamae — Thu, 28 May 2026 10:16:13 +0000

Originally published at ffmpeg-micro.com

Turning a folder of images into a playable video file is one of the most common FFmpeg tasks. Product screenshots for a demo reel, AI-generated frames for a social post, timelapse photos from a construction site. The command is short but the flags trip people up, especially -pix_fmt, -framerate, and image naming patterns.

FFmpeg can convert a numbered image sequence into an H.264 MP4 with one command.

The Basic Command: Image Sequence to MP4

If your images are named with sequential numbers (frame_001.png, frame_002.png, etc.):

ffmpeg -framerate 1 -i frame_%03d.png -c:v libx264 -pix_fmt yuv420p -r 30 output.mp4

What each flag does:

-framerate 1 tells FFmpeg to read one image per second. Change to 2 for half-second images, or 1/5 for five seconds per image.
-i frame_%03d.png is the input pattern. %03d matches zero-padded three-digit numbers.
-c:v libx264 encodes with H.264, the most widely supported video codec.
-pix_fmt yuv420p forces a pixel format compatible with every browser and player.
-r 30 sets the output frame rate to 30fps for smooth playback.

With 5 input images at -framerate 1, the output is a 5-second video.

Using Glob Patterns Instead of Numbered Files

ffmpeg -framerate 1 -pattern_type glob -i '*.png' -c:v libx264 -pix_fmt yuv420p -r 30 output.mp4

FFmpeg sorts glob matches alphabetically. Rename files with a numeric prefix if the order matters. Glob patterns work on macOS and Linux only.

One Image, Specific Duration

ffmpeg -loop 1 -i title-card.png -c:v libx264 -t 10 -pix_fmt yuv420p -r 30 output.mp4

-loop 1 keeps reading the same image. -t 10 sets 10 seconds of output.

Controlling Quality with CRF

ffmpeg -framerate 1 -i frame_%03d.png -c:v libx264 -pix_fmt yuv420p -crf 18 -r 30 high_quality.mp4
ffmpeg -framerate 1 -i frame_%03d.png -c:v libx264 -pix_fmt yuv420p -crf 28 -r 30 small_file.mp4

For 5 images at 640x360, CRF 18 produces a 176KB file. CRF 28 produces 61KB, a 2.9x size reduction. For product screenshots, stay between 18 and 22. For social media, 23 to 28 is fine.

Common Pitfalls

Dimensions must be even. H.264 requires width and height divisible by 2. Fix with -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2".

Alpha channels in PNGs cause playback failures. Always use -pix_fmt yuv420p.

Numbering gaps skip images. FFmpeg stops at gaps. Switch to a glob pattern.

Framerate confusion: -framerate (before -i) controls input read rate. -r (after -i) controls output frame rate.

FAQ

What image formats does FFmpeg support? JPEG, PNG, BMP, TIFF, WebP, and most standard formats.

How do I control duration per image? -framerate 1 = 1 second. -framerate 1/3 = 3 seconds per image.

Can I add transitions? Yes. FFmpeg's xfade filter supports 40+ transition styles.

Read the full post with API examples at ffmpeg-micro.com.

How to Use the FFmpeg MCP Server with Claude, Cursor, and Windsurf

Javid Jamae — Wed, 27 May 2026 10:16:59 +0000

Originally published at ffmpeg-micro.com.

Most FFmpeg MCP servers require you to install FFmpeg locally, manage binaries, and deal with codec dependencies. The FFmpeg Micro MCP server skips all of that. It connects your AI tool directly to a cloud video processing API. You describe what you want in plain English, and the AI handles the rest.

This guide shows you how to set it up in Claude Code, Claude Desktop, Cursor, or Windsurf, and walks through real examples you can run today.

What the FFmpeg Micro MCP Server Does

The FFmpeg Micro MCP server is a thin wrapper around the FFmpeg Micro REST API. It exposes six tools that your AI assistant can call:

transcode_video creates a transcode job and returns immediately
transcode_and_wait creates a job and polls until it finishes (one-shot convenience)
get_transcode checks the status of a specific job
list_transcodes lists your recent jobs with optional filters
get_download_url generates a signed download link for a completed job
cancel_transcode cancels a queued or in-progress job

The key difference from other FFmpeg MCP servers: there's no local FFmpeg binary. Video processing runs on FFmpeg Micro's cloud infrastructure. Your machine doesn't need FFmpeg installed, and you don't manage any servers.

Set Up in 2 Minutes

You need two things: an FFmpeg Micro account (free tier available at ffmpeg-micro.com) and an MCP-compatible AI tool.

Option 1: HTTP with OAuth (Zero Config)

This is the easiest setup. Add this to your MCP config file:

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

The first time you connect, your browser opens for OAuth sign-in. After that, the token is cached. No API key to copy-paste.

Where's the config file?

Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) or %APPDATA%\Claude\claude_desktop_config.json (Windows)
Claude Code: ~/.claude.json or project-level .mcp.json
Cursor: Settings > Cursor Settings > MCP
Windsurf: ~/.codeium/windsurf/mcp_config.json

Option 2: stdio via npx (API Key)

If you prefer local transport or your tool doesn't support HTTP MCP yet:

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

Requires Node.js 22.14 or later. Get your API key from the FFmpeg Micro dashboard.

Real Examples

Once connected, you just talk to your AI assistant. It picks the right MCP tools automatically.

Compress a Video to 720p

You type:

Compress this video to 720p medium quality: https://example.com/my-video.mp4

The AI calls transcode_video with:

{
  "inputs": [{ "url": "https://example.com/my-video.mp4" }],
  "outputFormat": "mp4",
  "preset": { "quality": "medium", "resolution": "720p" }
}

The API returns a job ID immediately. The AI then polls with get_transcode until the job completes, and fetches the download link with get_download_url.

A 13-second sample video processed in about 1 second with this exact call. The API returned:

{
  "id": "e643bb26-4753-4122-bd4c-ff90ccbee415",
  "status": "completed",
  "processing_time_seconds": 1,
  "duration_seconds": 13.35,
  "billable_minutes": 1
}

Convert MP4 to WebM

Convert my-video.mp4 to WebM format

The AI sends:

{
  "inputs": [{ "url": "https://example.com/my-video.mp4" }],
  "outputFormat": "webm"
}

No need to remember -c:v libvpx-vp9 -crf 30 -b:v 0. The API handles codec selection based on the output format.

Use Custom FFmpeg Flags

For full control, you can ask the AI to pass raw FFmpeg options:

Encode this video with H.265 at CRF 28, slow preset

The AI sends:

{
  "inputs": [{ "url": "https://example.com/my-video.mp4" }],
  "outputFormat": "mp4",
  "options": [
    { "option": "-c:v", "argument": "libx265" },
    { "option": "-crf", "argument": "28" },
    { "option": "-preset", "argument": "slow" }
  ]
}

The options array maps directly to FFmpeg flags. You get the full FFmpeg surface area without memorizing the syntax.

Batch Processing

Convert all three of these videos to 1080p MP4: video1.mp4, video2.mp4, video3.mp4

The AI can call transcode_video for each input, or use the multi-input feature to stitch them:

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

Multiple inputs get concatenated into a single output. For separate outputs, the AI makes three individual calls. Either way, you don't write any of it.

Common Pitfalls

"MCP server not found" after config change. Claude Desktop requires a full restart (not just closing the window) to pick up config changes. Cursor and Windsurf detect changes automatically.

OAuth popup doesn't appear. Make sure your browser isn't blocking popups from mcp.ffmpeg-micro.com. Some VPNs and corporate proxies also interfere with the OAuth redirect.

"Node.js version too old" with npx. The stdio transport requires Node.js 22.14+. Run node --version to check. If you're on an older version, use the HTTP transport instead.

Job stuck in "pending" status. Jobs process asynchronously on cloud infrastructure. If a job stays pending for more than 60 seconds, check your input URL. The most common cause is an unreachable or expired presigned URL.

Presigned URLs with query parameters. If your input URL already has query parameters (like S3 presigned URLs), make sure the full URL is passed as a single string. Don't split it.

FFmpeg MCP Server vs. Local FFmpeg MCP Servers

Other FFmpeg MCP servers (like egoist/ffmpeg-mcp, bitscorp-mcp/mcp-ffmpeg, and ZizoTheDev/ffmpeg-mcp) wrap a local FFmpeg binary. They're fine for personal use on a dev machine that already has FFmpeg installed. But they come with tradeoffs:

You need FFmpeg installed and configured locally (codec support varies by build)
Processing runs on your machine, which means CPU load and long runtimes for big files
No cloud scaling. A 4K video that takes 20 minutes locally might take 3 minutes on cloud infrastructure
No job management, no download URLs, no webhook notifications

FFmpeg Micro's MCP server processes video in the cloud. Your local machine stays idle. And because it's the same API that powers production apps, you get the same reliability, scaling, and job tracking.

FAQ

Do I need FFmpeg installed locally to use this?

No. The FFmpeg Micro MCP server processes everything in the cloud. You don't need FFmpeg, any codecs, or any video libraries on your machine.

How much does it cost?

FFmpeg Micro has a free tier for getting started. Paid plans bill per minute of video processed. Check ffmpeg-micro.com/pricing for current rates.

Which AI tools support MCP?

Claude Code, Claude Desktop, Cursor, Windsurf, and VS Code (via GitHub Copilot MCP) all support MCP servers. Any tool that implements the Model Context Protocol can connect.

Can I use this in production code, or just in AI tools?

The MCP server uses the same REST API that you can call directly from any language. The MCP layer is a convenience for AI-assisted development. For production, call the API directly. The FFmpeg Micro API works from Node.js, Python, Go, Ruby, Java, PHP, or any language with HTTP support.

What video formats are supported?

Input: MP4, WebM, AVI, MOV, MKV, plus audio formats (MP3, WAV, FLAC, AAC). Output: MP4, WebM, MOV. The API handles codec detection and selection automatically.

Last verified: 2026-05-27 against FFmpeg Micro MCP server v0.1.0 and API v1.0.0

How to Use FFmpeg with Go (Golang)

Javid Jamae — Tue, 26 May 2026 10:13:11 +0000

Originally published at ffmpeg-micro.com

You need video processing in your Go app. Maybe you're building a media pipeline, transcoding user uploads, or automating thumbnail generation. You search "ffmpeg golang" and find a few options. All of them require FFmpeg installed on the machine running your code.

That works on your laptop. It breaks the moment you deploy to a Docker container without FFmpeg compiled in, a serverless function with filesystem restrictions, or a CI environment that doesn't have the binary. There are three ways to approach this in Go, each with different tradeoffs.

Using os/exec to Call FFmpeg from Go

The most direct approach. Install FFmpeg on your system, then shell out from Go:

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("ffmpeg",
        "-i", "input.mp4",
        "-c:v", "libx264",
        "-crf", "23",
        "-preset", "medium",
        "-c:a", "aac",
        "-b:a", "128k",
        "output.mp4",
    )
    cmd.Stderr = cmd.Stdout

    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Printf("FFmpeg failed: %v\nOutput: %s\n", err, output)
        return
    }
    fmt.Println("Transcoding complete")
}

This is what most Go developers start with. It works, but you own everything: installing FFmpeg on every deployment target, parsing stderr for progress, handling the case where the binary isn't in PATH, and making sure the right codecs are compiled in. On a minimal Docker image like scratch or distroless, there's no FFmpeg at all. You'll need a multi-stage build or a fat base image that adds 80-200MB.

Using the ffmpeg-go Wrapper

The ffmpeg-go package (github.com/u2takey/ffmpeg-go) gives you a fluent API instead of raw command arguments:

package main

import (
    "fmt"
    ffmpeg "github.com/u2takey/ffmpeg-go"
)

func main() {
    err := ffmpeg.Input("input.mp4").
        Output("output.mp4", ffmpeg.KwArgs{
            "c:v":    "libx264",
            "crf":    "23",
            "preset": "medium",
            "c:a":    "aac",
            "b:a":    "128k",
        }).
        OverWriteOutput().
        Run()

    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Println("Done")
}

The builder pattern is cleaner than string slices. But ffmpeg-go still requires FFmpeg installed on the host. It's a wrapper around os/exec under the hood. You get a nicer API for constructing complex filter graphs, but the same deployment headaches apply. The library also hasn't seen frequent updates, so edge cases may go unpatched.

Processing Video with a Cloud API (No FFmpeg Install)

If you don't want to ship FFmpeg with your binary, you can offload processing to a cloud API. FFmpeg Micro gives you full FFmpeg capabilities through HTTP requests. From Go, it's just net/http:

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type TranscodeRequest struct {
    Inputs       []Input `json:"inputs"`
    OutputFormat string  `json:"outputFormat"`
    Preset       *Preset `json:"preset,omitempty"`
}

type Input struct {
    URL string `json:"url"`
}

type Preset struct {
    Quality    string `json:"quality"`
    Resolution string `json:"resolution"`
}

func main() {
    reqBody := TranscodeRequest{
        Inputs:       []Input{{URL: "https://example.com/input.mp4"}},
        OutputFormat: "mp4",
        Preset:       &Preset{Quality: "high", Resolution: "1080p"},
    }

    body, _ := json.Marshal(reqBody)
    req, _ := http.NewRequest("POST",
        "https://api.ffmpeg-micro.com/v1/transcodes",
        bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        fmt.Printf("Request failed: %v\n", err)
        return
    }
    defer resp.Body.Close()

    respBody, _ := io.ReadAll(resp.Body)
    fmt.Printf("Status: %d\nResponse: %s\n", resp.StatusCode, respBody)
}

No binary dependency. No Docker image bloat. Your Go binary stays small and deploys anywhere. The API handles scaling, codec management, and infrastructure. For advanced use cases, pass raw FFmpeg options instead of presets:

type Option struct {
    Option   string `json:"option"`
    Argument string `json:"argument"`
}

type AdvancedRequest struct {
    Inputs       []Input  `json:"inputs"`
    OutputFormat string   `json:"outputFormat"`
    Options      []Option `json:"options"`
}

reqBody := AdvancedRequest{
    Inputs:       []Input{{URL: "https://example.com/input.mp4"}},
    OutputFormat: "webm",
    Options: []Option{
        {Option: "-c:v", Argument: "libvpx-vp9"},
        {Option: "-crf", Argument: "30"},
        {Option: "-b:v", Argument: "0"},
    },
}

Same FFmpeg flags you already know, sent as structured data instead of a command-line string.

Which Approach Should You Use

os/exec if you need full control over FFmpeg and you can guarantee the binary is available in every environment your code runs in.

ffmpeg-go if you want a cleaner API for complex filter chains and don't mind the native FFmpeg dependency. Good for local tools and media pipelines where you control the host.

A cloud API like FFmpeg Micro if you're deploying to containers, serverless, or anywhere installing FFmpeg is impractical. Also the right choice when you don't want to manage scaling, codecs, or infrastructure yourself.

Common Pitfalls with FFmpeg in Go

"exec: ffmpeg: executable file not found in $PATH." The classic. Your code works locally but panics in Docker because the image doesn't include FFmpeg. Always test your Docker build with docker run --rm your-image which ffmpeg before deploying.

Stderr vs stdout confusion. FFmpeg writes progress and diagnostic info to stderr, not stdout. If you're only reading cmd.Output(), you'll miss error messages entirely. Use cmd.CombinedOutput() or attach cmd.Stderr to a buffer.

Goroutine leaks on long jobs. If you spawn a transcode in a goroutine and the HTTP request that triggered it times out, the FFmpeg process keeps running. Use exec.CommandContext with a context.WithTimeout to kill the process when the caller cancels.

Large file memory pressure. Piping FFmpeg output through Go's io.ReadAll on a 2GB file will spike memory. Stream the output to disk or to cloud storage instead of buffering it in memory.

Frequently Asked Questions

Do I need FFmpeg installed to process video in Go?

With os/exec and ffmpeg-go, yes. Both require the FFmpeg binary on the host machine. A cloud API like FFmpeg Micro processes video entirely server-side, so your Go app never touches FFmpeg directly.

Can I use FFmpeg in a Go app deployed to AWS Lambda?

You can bundle a static FFmpeg binary in your deployment package. But Lambda has memory limits (128MB-10GB), a 15-minute execution ceiling, and a 250MB package size limit. A 5-minute 1080p transcode can easily exceed all three. Offloading to an API keeps your Lambda small and fast.

What's the fastest way to add video processing to a Go application?

A cloud API gets you from zero to processing video in under 10 minutes. Define your structs, make an HTTP call, poll for completion. No installation, no Docker configuration, no codec debugging. FFmpeg Micro's free tier gives you enough processing time to build and test your integration.

Is ffmpeg-go still maintained?

The github.com/u2takey/ffmpeg-go package works for most common operations, but it hasn't had a major release recently. For simple transcoding it's fine. For bleeding-edge FFmpeg features or complex filter graphs, you may find yourself falling back to os/exec with raw arguments.

Last verified: 2026-05-26 against FFmpeg 7.1 and ffmpeg-micro API v1

How to Use FFmpeg with Java (No Installation Required)

Javid Jamae — Mon, 25 May 2026 10:16:01 +0000

Originally published at ffmpeg-micro.com

You need video processing in your Java app. Maybe you're transcoding user uploads in a Spring Boot service, generating thumbnails for a content platform, or converting formats in an enterprise pipeline. You search "ffmpeg java" and find a dozen approaches, half of them outdated.

FFmpeg is the standard for video processing. But integrating it with Java means choosing between shelling out to a binary, using a wrapper library, or skipping the local install entirely. Each approach has real tradeoffs. This post covers all three with working code so you can pick the right one for your project.

Running FFmpeg from Java with ProcessBuilder

The most direct approach. Install FFmpeg on the machine, then call it from Java using ProcessBuilder:

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

try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(process.getInputStream()))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

int exitCode = process.waitFor();
if (exitCode != 0) {
    throw new RuntimeException("FFmpeg failed with exit code " + exitCode);
}

This works. But you own everything: installing FFmpeg on every server and CI machine, parsing stderr for progress info, handling missing codecs, and managing the binary across Linux/Mac/Windows. On Docker, FFmpeg adds 80-200MB to your image. On serverless (Lambda, Cloud Functions), you're stuck with a 250MB package limit and can't install system binaries at all.

Using Jaffree for a Cleaner API

Jaffree is the most capable Java FFmpeg wrapper. It gives you a fluent builder API instead of raw string arrays:

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 out of the box:

FFmpeg.atPath()
    .addInput(UrlInput.fromUrl("input.mp4"))
    .addOutput(UrlOutput.toUrl("output.mp4")
        .addArguments("-c:v", "libx264")
        .addArguments("-crf", "23"))
    .setProgressListener(progress ->
        System.out.printf("Frame: %d, Time: %s%n",
            progress.getFrame(), progress.getTimeMark()))
    .execute();

The API is better than raw ProcessBuilder code. But Jaffree still requires FFmpeg installed on the host. It's a wrapper around the CLI binary, not a replacement for it. You still manage installations, updates, and codec availability across environments.

Processing Video with a Cloud API (No FFmpeg Install)

If you don't want FFmpeg on your servers at all, you can offload processing to a cloud API. FFmpeg Micro gives you full FFmpeg capabilities through HTTP requests. Java 11+ includes java.net.http.HttpClient, so you don't even need a third-party HTTP library:

HttpClient client = HttpClient.newHttpClient();

String requestBody = """
    {
        "inputs": [{"url": "https://example.com/input.mp4"}],
        "outputFormat": "mp4",
        "preset": {"quality": "high", "resolution": "1080p"}
    }
    """;

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.ffmpeg-micro.com/v1/transcodes"))
    .header("Authorization", "Bearer " + apiKey)
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(requestBody))
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

System.out.println(response.body());
// {"id":"b5f5a9c0-...","status":"queued","output_format":"mp4",...}

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

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

String advancedBody = """
    {
        "inputs": [{"url": "https://example.com/input.mp4"}],
        "outputFormat": "webm",
        "options": [
            {"option": "-c:v", "argument": "libvpx-vp9"},
            {"option": "-crf", "argument": "30"},
            {"option": "-b:v", "argument": "0"}
        ]
    }
    """;

Polling for Completion

Transcode jobs are asynchronous. Poll the status endpoint until the job finishes:

String jobId = // parse id from the create response
String statusUrl = "https://api.ffmpeg-micro.com/v1/transcodes/" + jobId;

HttpRequest statusRequest = HttpRequest.newBuilder()
    .uri(URI.create(statusUrl))
    .header("Authorization", "Bearer " + apiKey)
    .GET()
    .build();

String status = "queued";
while ("queued".equals(status) || "processing".equals(status)) {
    Thread.sleep(2000);
    HttpResponse<String> statusResponse = client.send(statusRequest,
        HttpResponse.BodyHandlers.ofString());
    // Parse status from JSON response
    status = parseStatus(statusResponse.body());
}

Once the status is completed, grab the download URL:

String downloadUrl = "https://api.ffmpeg-micro.com/v1/transcodes/" + jobId + "/download";
HttpRequest downloadRequest = HttpRequest.newBuilder()
    .uri(URI.create(downloadUrl))
    .header("Authorization", "Bearer " + apiKey)
    .GET()
    .build();

HttpResponse<String> downloadResponse = client.send(downloadRequest,
    HttpResponse.BodyHandlers.ofString());
// Response: {"url": "https://storage.googleapis.com/...signed-url..."}

The signed URL is valid for 10 minutes. Download the file directly from it.

CLI vs. API: Side-by-Side

The same operation (converting an MP4 to 720p) done both ways:

FFmpeg CLI (requires local install):

ffmpeg -i input.mp4 -vf scale=-2:720 -c:v libx264 -crf 23 -c:a copy output.mp4

FFmpeg Micro API (no install):

String body = """
    {
        "inputs": [{"url": "https://example.com/input.mp4"}],
        "outputFormat": "mp4",
        "preset": {"quality": "high", "resolution": "720p"}
    }
    """;

Same result. The API version runs on managed infrastructure that scales automatically. The CLI version runs on whatever machine you installed FFmpeg on.

Common Pitfalls with FFmpeg in Java

ProcessBuilder doesn't capture stderr by default. FFmpeg writes progress and error info to stderr, not stdout. If you only read getInputStream(), you miss all of it. Always call redirectErrorStream(true) or read both streams separately with threads to avoid deadlocks.

Blocking on process output can deadlock. If FFmpeg writes enough data to fill the OS pipe buffer and your Java code isn't reading it, both processes freeze. Always drain the output stream in a separate thread or use redirectErrorStream(true) with a reader loop.

Jaffree needs FFmpeg on the PATH. If FFmpeg isn't on the system PATH, Jaffree throws a confusing IOException. Either pass the path explicitly with FFmpeg.atPath(Paths.get("/usr/local/bin")) or set it in your container's Dockerfile.

Text blocks need Java 13+. The multi-line """ syntax used in the API examples requires Java 13 or later. On older versions, use string concatenation or a JSON library like Jackson to build the request body.

Don't forget to close processes. A leaked Process object holds OS resources. Use try-with-resources or call process.destroy() in a finally block. Jaffree handles this automatically.

Which Approach Should You Use?

ProcessBuilder if you need full control over FFmpeg flags and you're comfortable managing FFmpeg installations across all environments. Good for batch processing on dedicated servers where you control the OS.

Jaffree if you want a cleaner Java API and built-in progress tracking. Still requires FFmpeg on every machine, but the code is easier to maintain than raw ProcessBuilder calls.

A cloud API like FFmpeg Micro if you want zero operational overhead. Best for serverless deployments, microservices, or teams that don't want to manage FFmpeg infrastructure. You get a free API key to start processing video in under 10 minutes.

FAQ

Can I run FFmpeg inside AWS Lambda with Java?

Technically, yes. You can bundle a static FFmpeg binary in your deployment package. But Lambda has a 250MB package limit (unzipped), 512MB /tmp storage, and a 15-minute timeout. For short clips it works. For anything over a few minutes of video, you'll hit limits. A cloud API avoids these constraints entirely.

Is Jaffree still maintained?

Yes. Jaffree is actively maintained on GitHub with regular releases. It supports Java 8+ and wraps both ffmpeg and ffprobe. It's the most mature FFmpeg wrapper for Java.

What about JavaCV for video processing?

JavaCV wraps OpenCV and FFmpeg via JNI bindings. It's built for computer vision tasks (face detection, frame analysis) but heavyweight for simple transcoding. If you just need to convert formats or resize video, ProcessBuilder, Jaffree, or a cloud API are simpler options.

How does the FFmpeg Micro API handle large files?

For files you can't reference by URL, use the upload flow: request a presigned URL, PUT your file directly to cloud storage, confirm the upload, then reference the cloud storage URL in your transcode request. The API supports files up to 2GB.

Do I need to learn FFmpeg syntax to use the API?

No. Presets handle common operations (quality levels, resolution, format conversion) without any FFmpeg knowledge. If you do know FFmpeg, you can pass raw options for full control over codecs, filters, and encoding parameters.

Last verified: 2026-05-25 against FFmpeg 7.x and FFmpeg Micro API v1