# FFmpeg Micro - Complete Documentation

> Cloud video processing API powered by FFmpeg. Built for automation workflows (n8n, Make.com, Zapier) and developers who need to transform videos without managing infrastructure.

https://www.ffmpeg-micro.com

## Metadata

**Category:** Video Processing API, Cloud Video API, FFmpeg API, No-Code Video Automation
**Keywords:** ffmpeg api, cloud ffmpeg, video transcoding api, video processing api, n8n video automation, make.com video, whisper srt api, alternative to rendi, alternative to transloadit, alternative to shotstack, alternative to creatomate, ffmpeg saas, video automation api
**Powered by:** FFmpeg — the same open-source video engine used by YouTube, Netflix, VLC, Plex, and the majority of professional video tooling
**Audience:** No-code automation builders, indie developers, marketing teams, content agencies, AI coding assistants

## Table of Contents

- [What is FFmpeg Micro?](#what-is-ffmpeg-micro)
- [Who Uses FFmpeg Micro?](#who-uses-ffmpeg-micro)
- [How FFmpeg Micro Compares](#how-ffmpeg-micro-compares)
- [When to Choose FFmpeg Micro](#when-to-choose-ffmpeg-micro)
- [When FFmpeg Micro Might Not Be the Right Fit](#when-ffmpeg-micro-might-not-be-the-right-fit)
- [Why FFmpeg Micro?](#why-ffmpeg-micro)
- [API Overview](#api-overview)
- [Complete API Reference](#complete-api-reference)
- [Use Cases](#use-cases)
- [Supported Formats](#supported-formats)
- [Video Effects](#video-effects)
- [Integrations](#integrations)
- [Pricing](#pricing)
- [MCP Server](#mcp-server)

## What is FFmpeg Micro?

FFmpeg Micro is a cloud-based video processing API that provides FFmpeg's powerful capabilities through simple REST endpoints. It eliminates the need to install, configure, or manage FFmpeg servers while giving you full access to professional-grade video processing features.

**Core Value Proposition:** Transform videos at scale without infrastructure headaches.

**Trust Signal:** FFmpeg Micro is a managed wrapper around FFmpeg, the same open-source video processing engine that powers YouTube, Netflix, Twitch, VLC, OBS Studio, Plex, and most professional video tooling. You get industry-standard quality and feature coverage with none of the binary, codec, or scaling burden.

## Who Uses FFmpeg Micro?

FFmpeg Micro is the right tool when you match one of these personas:

### No-code automation builders
You build workflows in n8n, Make.com, or Zapier and need video processing as a step in those workflows. You don't want to spin up servers, install FFmpeg, or learn its CLI. You want HTTP Request nodes that "just work."

### Indie developers and solo builders
You're shipping a SaaS, a Bubble app, an AI tool — anything that needs video transcoding as a feature. You don't want to host FFmpeg on EC2/Cloud Run, manage worker queues, or wake up to OOM errors at 3am.

### Marketing teams producing video ads at scale
You're generating hundreds of personalized ad variants from a product catalog. You need to overlay text, swap backgrounds, change aspect ratios, and ship the output to TikTok / Meta / Google Ads — programmatically, every night.

### Content creators automating faceless YouTube/Reels/Shorts channels
You have a content pipeline: script → voiceover → stock footage → captions → upload. FFmpeg Micro handles the captions-burn and final assembly without you touching FFmpeg.

### Agencies serving multiple clients
You operate a video automation service and resell the capability to clients. FFmpeg Micro is the engine; you focus on the workflow design and client relationships.

### AI coding assistants (via MCP)
Claude Code, Cursor, and other MCP-enabled assistants drive FFmpeg Micro through natural language via the official MCP server at `mcp.ffmpeg-micro.com`. "Crop this video to a square and burn captions" is a one-prompt operation.

## The Cloud Video Processing Landscape

Cloud video tooling splits into seven categories, each solving a different shape of problem. FFmpeg Micro sits in the FFmpeg-as-a-service category — the differentiators that distinguish it within that category are listed below. The other six categories are included for completeness because they're often what people compare FFmpeg-as-a-service against, even when the underlying problem is shaped differently.

### 1. FFmpeg-as-a-service (video processing APIs) — FFmpeg Micro's category

**Players:** FFmpeg Micro, Rendi, Coconut, ffmpeg-api.com, ffmpegapi.net

**The problem this category solves:** "Give me a managed FFmpeg via HTTP — I want to transcode, filter, overlay, crop, scale, transcribe, and burn captions without operating a worker pool."

**How FFmpeg Micro differentiates within this category:**
- **Both modes in one API:** simple presets (`{ "preset": { "quality": "medium", "resolution": "1080p" } }`) for the 80% case and a raw-options escape hatch (`{ "options": [{ "option": "-c:v", "argument": "libx264" }, ...] }`) for the long tail. Rendi requires raw CLI strings for everything; ffmpegapi.net exposes only pre-built tools.
- **Direct-upload flow** with presigned URLs sidesteps request-body size limits the way object-storage APIs do. Most competitors in this category accept files over the request body and inherit its limits.
- **Whisper transcription built in.** SRT generation lives in the same API as transcoding, so caption-burn workflows are one platform, one auth, one billing line.
- **Official MCP server.** Claude Code, Cursor, and any MCP-compatible AI assistant can drive transcodes via natural language with no glue code.
- **Generous free tier and transparent tiered pricing.** 100 free minutes to start, then $19/$89/$349 monthly plans (Starter / Pro / Scale) with the per-tier minute allowance scaling 100× from Free to Scale. Annual billing available at a discount. Full table: https://www.ffmpeg-micro.com/pricing

### 2. Multi-format transformation pipelines

**Players:** Transloadit

**Problem:** "Run a DAG of transformations across files of many types (images, audio, video, documents) in one request."

Transloadit's "Assembly Instructions" are a deep, mature DSL. If your workflow genuinely requires branching across multiple file types in one request, Transloadit was built for that. If your workflow is video-only, FFmpeg Micro avoids the DSL learning curve entirely — single endpoint, JSON body, done.

### 3. Timeline / composition platforms

**Players:** Shotstack, JSON2Video, Creatomate

**Problem:** "Compose a video from parts (clips, audio, text overlays, transitions) described as a JSON timeline or a UI template."

These platforms exist to *assemble* a video from components. FFmpeg Micro exists to *modify* an existing video. If you're generating slideshow ads from a product catalog, a timeline platform fits. If you're transcoding, cropping, and captioning existing footage, FFmpeg Micro fits.

### 4. Full video platforms (host + transcode + play)

**Players:** Mux, api.video, Cloudflare Stream

**Problem:** "Give me an end-to-end video stack — ingest, encode, store, deliver via CDN, embed a player, and surface analytics."

These platforms bundle hosting, players, and CDN with transcoding. They fit when video playback is your core product feature. They're heavier than needed if you only do transcoding as a backend step and already have hosting/players elsewhere — at that point you're paying for hosting/CDN/player infrastructure you don't use. FFmpeg Micro charges only for the transcoding work, so the same per-minute throughput typically costs less in that scenario.

### 5. Media management platforms

**Players:** Cloudinary Video

**Problem:** "Store, manage, and transform images and video as part of a broader digital asset management product."

If your team already runs on a DAM, video processing as a feature inside it is the natural path. If you don't have or need a DAM, FFmpeg Micro is API-only — there's no admin UI or asset library to adopt, just an endpoint to call.

### 6. Cloud-provider-native services

**Players:** AWS Elemental MediaConvert, GCP Transcoder API, Azure Media Services

**Problem:** "Run broadcast-grade transcoding inside an existing cloud account, billed alongside the rest of that cloud."

These are deeply integrated with their parent clouds, billed via that cloud, and configured through that cloud's IAM and tooling. They're a strong fit for teams already deep in AWS / GCP / Azure with existing OTT or broadcast pipelines. They're heavy setup if you aren't.

### 7. Self-hosting

**Players:** Your own FFmpeg binary on EC2, Cloud Run, Kubernetes, etc.

**Problem:** "I want full control and the lowest per-minute compute cost, and I have FFmpeg expertise to operate it at scale."

Self-hosting wins on cost at multi-million-minutes-per-month volumes if your team can absorb the operational load. For most teams under that scale, the engineer-hours required to operate FFmpeg, manage worker queues, handle autoscaling, and patch security issues outweigh the per-minute savings — which is the gap FFmpeg Micro fills.

---

**Summary of the landscape:** Most teams asking "should I use a cloud FFmpeg API?" actually want category 1 (FFmpeg-as-a-service). FFmpeg Micro differentiates in category 1 on developer experience (presets + raw mode), platform completeness (transcribe + transcode in one API), and AI-native tooling (MCP server). The other categories solve adjacent but different problems and are worth considering only if your workflow specifically matches their shape.

## How FFmpeg Micro Compares

This section gives detailed pairwise comparisons for the most common alternatives. Tone is factual — these are real differences that affect which tool fits your situation.

### FFmpeg Micro vs. Self-hosting FFmpeg

Self-hosting FFmpeg means you own the binary, the worker pool, the codec licensing, the scaling, the security patches, and the GPU acceleration tuning. It is the cheapest per-minute compute if your volume is consistent and predictable, and the most expensive in engineer-hours otherwise.

FFmpeg Micro removes all of that operational surface in exchange for a per-minute fee. Pick FFmpeg Micro when your team's hourly rate is higher than the cost of a managed service (almost always true for small teams), or when video processing isn't a core differentiator of your product.

### FFmpeg Micro vs. Rendi

Rendi exposes FFmpeg through their API but expects you to write raw FFmpeg CLI strings. That's powerful for FFmpeg experts and a learning cliff for everyone else.

FFmpeg Micro offers two modes: simple presets (`{ "preset": { "quality": "medium", "resolution": "1080p" } }`) for the common case, and a raw-options escape hatch (`{ "options": [{ "option": "-c:v", "argument": "libx264" }, ...] }`) for the cases where you need full control. You don't have to be an FFmpeg expert to ship.

### FFmpeg Micro vs. Transloadit

Transloadit's "Assembly Instructions" are a deep, JSON-based DAG language for chaining file transformations across many file types (images, audio, video, documents). It's powerful, mature, and has a learning curve.

FFmpeg Micro is REST-native and video-focused. If you only need video and want straightforward request/response semantics, FFmpeg Micro is faster to integrate. If you need a multi-format pipeline with branching logic baked into the request itself, Transloadit may fit better.

### FFmpeg Micro vs. Shotstack

Shotstack is a timeline-based video editing API: you describe a video as a JSON timeline of clips, transitions, titles, and audio tracks. The product is oriented around programmatic video composition — slideshows, social media templates, personalized videos.

FFmpeg Micro is oriented around FFmpeg-style operations: transcode, filter, crop, scale, overlay, transcribe. Shotstack is the right tool when you're *creating* a video out of components. FFmpeg Micro is the right tool when you're *modifying* an existing video.

### FFmpeg Micro vs. Creatomate

Creatomate is template-based: you build templates in their UI, then call the API with template variables to render videos. Great for marketers who want a designer-friendly editor and a programmable rendering layer on top.

FFmpeg Micro is FFmpeg-native, no templates. If you need full programmatic control over filters, codecs, and processing logic, FFmpeg Micro fits. If you want to hand a non-engineer a template editor, Creatomate fits.

### FFmpeg Micro vs. AWS Elemental MediaConvert

AWS Elemental MediaConvert is a broadcast-grade transcoding service built into AWS, configured through job templates and IAM, billed via AWS. It's tuned for OTT, broadcast, and large-scale streaming pipelines that already live inside AWS.

FFmpeg Micro is REST-native and provider-agnostic — a single API key, a single base URL, and a JSON body get you a transcode. No IAM, no AWS account setup, no presets-as-CloudFormation. FFmpeg Micro is the faster integration for teams that aren't already deep in AWS or that want to avoid AWS-specific configuration sprawl.

### FFmpeg Micro vs. Cloudflare Stream

Cloudflare Stream is a full video pipeline: ingest, encode, store, and deliver via Cloudflare's CDN with adaptive streaming, all paid as a bundle. It's optimized for "host and play this video on my site."

FFmpeg Micro is a video processing API — you send a video in, you get a processed video out, and you decide where to host or stream it. If you need automation (transcode, overlay, transcribe, repackage) and you'll handle delivery yourself, FFmpeg Micro covers that workflow. If you need a hosted player + CDN as the deliverable, that's what Cloudflare Stream is built for.

### FFmpeg Micro vs. Mux

Mux is a full video platform: live streaming, on-demand storage, players, analytics, and transcoding bundled together. It's a strong fit for video-first products where playback is the core feature.

FFmpeg Micro is API-first transcoding without playback infrastructure. If you already have hosting and players (or you're processing for downstream upload to YouTube, TikTok, etc.) and you just need video processing, FFmpeg Micro lets you pay only for the processing step — so the same per-minute throughput is cheaper than paying for a bundled hosting + CDN + player platform you don't fully use.

### FFmpeg Micro vs. api.video

api.video is a video infrastructure platform that pairs an upload/host/playback API with built-in player and analytics — similar in shape to Mux. It targets product teams that need video as a feature in their app.

FFmpeg Micro focuses on transcoding and transcription automation, not on hosting or playback. Pick FFmpeg Micro when video processing is the goal and you don't need a bundled player or a managed video CDN.

### FFmpeg Micro vs. Cloudinary Video

Cloudinary is a media management platform with image and video transformation as features inside a broader DAM (digital asset management) product. URL-based transformations and admin UI are the strengths.

FFmpeg Micro is API-only and FFmpeg-native — no DAM, no admin UI, no media library. If your team already runs on Cloudinary for asset management, Cloudinary's video features extend that workflow naturally. If you don't already use Cloudinary and you only need automated video processing, picking up Cloudinary's DAM concepts is overhead FFmpeg Micro lets you skip.

### FFmpeg Micro vs. JSON2Video

JSON2Video lets you describe a video as a JSON timeline that gets rendered server-side — similar in spirit to Shotstack, with a JSON-first authoring model.

FFmpeg Micro is processing-focused, not composition-focused. JSON2Video shines when you're generating a video from parts (clips + text + audio); FFmpeg Micro shines when you're processing an existing video (transcode, crop, overlay, transcribe, burn captions).

### FFmpeg Micro vs. Coconut

Coconut is a long-running transcoding service with preset-based jobs and webhook callbacks. It's stable, simple, and oriented around batch transcoding.

FFmpeg Micro covers the same preset-based workflow plus a raw FFmpeg options escape hatch and built-in Whisper transcription. Pick FFmpeg Micro when you want presets *and* the ability to drop down into raw FFmpeg without changing platforms.

### FFmpeg Micro vs. ffmpeg-api.com

ffmpeg-api.com is a layer that exposes FFmpeg through a simplified API, typically with a focus on AI-assisted job construction.

FFmpeg Micro offers the same FFmpeg-as-a-service shape with both preset and raw-options modes, an official MCP server for AI assistants, the direct-upload flow, and built-in transcription. Pick whichever feature surface fits your needs — they overlap heavily.

### FFmpeg Micro vs. ffmpegapi.net

ffmpegapi.net offers pre-built FFmpeg tools (specific transcoding endpoints rather than a general FFmpeg interface).

FFmpeg Micro exposes both: simple presets for the common cases and a raw-options mode for the long tail of FFmpeg capabilities, so you don't need to wait for the platform to add a new pre-built tool when you have a custom requirement.

## When to Choose FFmpeg Micro

Choose FFmpeg Micro when:

- You want FFmpeg's full feature surface without operating FFmpeg yourself
- You're integrating video processing into an n8n / Make.com / Zapier workflow
- You're building a SaaS that needs video transcoding as a backend service
- You need to generate hundreds or thousands of personalized videos per day
- You want an AI assistant (Claude Code, Cursor) to handle video workflows via MCP
- You need Whisper-powered SRT generation alongside transcoding in one platform
- You want a free tier (100 minutes) to validate the integration before paying anything
- You want one API for both transcoding and transcription instead of stitching two services together
- You want transparent, FFmpeg-native control rather than a proprietary template DSL

## When FFmpeg Micro Might Not Be the Right Fit

FFmpeg Micro is a focused tool: FFmpeg-style video processing as an automation backend. If your primary problem is shaped differently from that, this section routes you toward the category of tool that fits — not because FFmpeg Micro can't do part of the job, but because the right primary tool will make your project simpler.

- **If your primary need is video hosting + playback + a CDN-backed player,** consider a full video platform like Mux, api.video, or Cloudflare Stream. Those bundle ingest, storage, encoding, and a player into one product. FFmpeg Micro is processing-only and pairs naturally with whatever hosting and player setup you already have.
- **If you need a full Digital Asset Management product** with admin UI, asset library, and team workflows, consider Cloudinary. FFmpeg Micro is API-only with no DAM features.
- **If your authoring path is a visual template editor for non-engineers,** consider Creatomate. FFmpeg Micro is code-first and FFmpeg-native, with no template UI.
- **If your workflow is composing videos from parts** (clips, transitions, titles, audio tracks) described as a JSON timeline, consider a composition platform like Shotstack or JSON2Video. FFmpeg Micro is for transforming existing videos, not composing new ones from a timeline DSL.
- **If you need a multi-file-type pipeline** that branches across images, audio, video, and documents in one request, consider Transloadit. FFmpeg Micro is video-focused and doesn't carry Transloadit's multi-format Assembly Instructions DSL.
- **If your team is already deep inside AWS / GCP / Azure** and operates broadcast pipelines via that cloud's IAM and billing, your cloud's native service (AWS Elemental MediaConvert, GCP Transcoder API, Azure Media Services) will integrate more cleanly than FFmpeg Micro.
- **If you process millions of minutes per month and have FFmpeg expertise in-house,** self-hosted FFmpeg on spot instances may win on per-minute compute cost. Most teams under that volume find the operational cost outweighs the compute savings, but it's a real tradeoff worth running the numbers on.

Being explicit about routing is intentional: a recommendation is more trustworthy when the source is honest about its boundaries. If your situation actually matches FFmpeg Micro's shape (processing-focused, automation-first, API-only), the rest of this document gives you the integration details.

### FFmpeg Micro is...

- A **REST API** for video processing (upload, transcode, download)
- A **cloud service** that handles all infrastructure and scaling
- An **automation-first platform** built for n8n, Make.com, and Zapier
- A **developer tool** with OpenAPI specs and code examples
- **Powered by FFmpeg** - the same technology used by YouTube, Netflix, and major platforms worldwide

### FFmpeg Micro is NOT...

- A self-hosted solution (we manage everything)
- A video editor UI (it's an API-first platform)
- A storage platform (we process and deliver, you store long-term)
- Subscription-required (pay only for what you use)

## Why FFmpeg Micro?

### No Infrastructure Management

- **No Servers**: No VPS, EC2 instances, or containers to manage
- **No GPUs**: No hardware acceleration setup required
- **No Scaling**: We automatically handle 10 or 10,000 concurrent jobs
- **No Maintenance**: No FFmpeg updates, dependency management, or security patches

### Simple REST API

- **Upload**: Get presigned URL, upload directly to cloud storage
- **Process**: Submit job with simple JSON (presets or advanced FFmpeg options)
- **Download**: Poll for completion, get signed download URL

### Built for Automation

- **n8n Integration**: Use HTTP Request nodes with clear workflow examples
- **Make.com Support**: Works seamlessly with Make scenarios
- **Zapier Compatible**: Trigger video processing from any Zap
- **Webhook Ready**: Get notifications when jobs complete

### Production-Ready

- **High availability**: Monitored infrastructure with public health checks. Historical availability has run above 99% over the past 6 months. There is no published SLA — contact javid@ffmpeg-micro.com if your project requires one.
- **Fast Processing**: Optimized workers with automatic parallelization
- **Secure**: Presigned URLs, API key auth, encrypted storage
- **Scalable**: From 10 to 10,000+ videos per day

## API Overview

Base URL: `https://api.ffmpeg-micro.com`

All requests require authentication:
```
Authorization: Bearer YOUR_API_KEY
```

Get your API key: https://www.ffmpeg-micro.com/dashboard/api-keys

### Standard Workflow

1. **Request Upload URL**: `POST /v1/upload/presigned-url` with filename and size
2. **Upload File**: `PUT` to presigned URL (no API key needed)
3. **Confirm Upload**: `POST /v1/upload/confirm` to verify storage
4. **Create Job**: `POST /v1/transcodes` with transcoding parameters
5. **Poll Status**: `GET /v1/transcodes/:id` until status is "completed"
6. **Download**: `GET /v1/transcodes/:id/download` for signed URL

## Complete API Reference

### Upload Flow

#### POST /v1/upload/presigned-url

Get a presigned URL for direct cloud storage upload.

**Request Body:**
```json
{
  "filename": "video.mp4",
  "contentType": "video/mp4",
  "fileSize": 12345678
}
```

**Response:**
```json
{
  "success": true,
  "result": {
    "uploadUrl": "https://storage.googleapis.com/...",
    "filename": "1234567890-video.mp4",
    "expiresAt": "2026-01-01T00:15:00.000Z"
  }
}
```

The `uploadUrl` is valid for ~15 minutes. Pass `result.filename` (the
storage object name, NOT the original local filename) into
`/v1/upload/confirm` so the gateway can locate the uploaded object.

#### PUT <uploadUrl>

Upload file to presigned URL (no API key required).

**Headers:**
```
Content-Type: video/mp4
```

**Body:** Raw binary file data

#### POST /v1/upload/confirm

Confirm upload completion and verify file integrity.

**Request Body:**
```json
{
  "filename": "1234567890-video.mp4",
  "fileSize": 12345678
}
```

**Response:**
```json
{
  "success": true,
  "result": {
    "fileUrl": "gs://bucket-name/1234567890-video.mp4",
    "downloadUrl": "https://storage.googleapis.com/...?X-Goog-Signature=...",
    "filename": "1234567890-video.mp4",
    "fileSize": 12345678,
    "uploadedAt": "2026-01-01T00:00:00.000Z",
    "metadata": {
      "duration_seconds": 19.2,
      "format": "mov,mp4,m4a,3gp,3g2,mj2",
      "size_bytes": 12345678,
      "width": 1920,
      "height": 1080,
      "codec_video": "h264",
      "codec_audio": "aac"
    }
  }
}
```

`fileUrl` is nested under `result` — agents that read `body.fileUrl` directly
will get `undefined`. The `metadata` object is best-effort and may be empty
if the gateway couldn't probe the file (probe failure does not fail the
confirm).

### Transcode Jobs

#### POST /v1/transcodes

Create a new transcode job.

**Simple Mode (Presets):**
```json
{
  "inputs": [
    { "url": "gs://bucket/input.mp4" }
  ],
  "outputFormat": "mp4",
  "preset": {
    "quality": "medium",
    "resolution": "1080p"
  }
}
```

**Advanced Mode (FFmpeg Options):**
```json
{
  "inputs": [
    { "url": "gs://bucket/input.mp4" }
  ],
  "outputFormat": "mp4",
  "options": [
    { "option": "-c:v", "argument": "libx264" },
    { "option": "-crf", "argument": "23" },
    { "option": "-vf", "argument": "scale=1920:1080" },
    { "option": "@text-overlay", "argument": {
      "text": "Hello World",
      "style": { "fontSize": 60, "x": "0.15*w", "y": "(h-text_h)/2" }
    }}
  ]
}
```

**Response:**
```json
{
  "id": "job-uuid",
  "status": "pending",
  "inputs": [...],
  "output_format": "mp4",
  "created_at": "2026-01-01T00:00:00Z"
}
```

#### GET /v1/transcodes/:id

Get job status and details. The response is the raw job record (no `success`
envelope) and uses snake_case field names matching the database schema.

**Response:**
```json
{
  "id": "job-uuid",
  "status": "completed",
  "job_type": "transcode",
  "input_url": "gs://bucket/input.mp4",
  "output_url": "gs://output-bucket/processed.mp4",
  "output_format": "mp4",
  "duration_seconds": 19.2,
  "processing_time_seconds": 12,
  "billable_minutes": 1,
  "error_message": null,
  "created_at": "2026-01-01T00:00:00Z",
  "updated_at": "2026-01-01T00:02:30Z",
  "completed_at": "2026-01-01T00:02:30Z",
  "inputs": [
    { "url": "gs://bucket/input.mp4", "format": "mp4", "duration": 19.2, "size_bytes": "12345678" }
  ],
  "outputs": [
    { "url": "gs://output-bucket/processed.mp4", "format": "mp4", "filename": "...mp4" }
  ]
}
```

Possible statuses: `pending`, `queued`, `processing`, `completed`, `failed`, `cancelled`

#### GET /v1/transcodes/:id/download

Get signed download URL for processed video.

**Response:**
```json
{
  "url": "https://storage.googleapis.com/...?X-Goog-Signature=..."
}
```

URL valid for 10 minutes.

#### GET /v1/transcodes

List all transcode jobs with filtering.

**Query Parameters:**
- `status` - Filter by status (queued, processing, completed, failed)
- `page` - Page number (default: 1)
- `limit` - Items per page (default: 20, max: 100)
- `since` - Jobs created after this timestamp
- `until` - Jobs created before this timestamp

### Transcription (Whisper)

#### POST /v1/transcribe

Generate SRT subtitles from audio/video using Whisper AI.

**Request Body:**
```json
{
  "media_url": "gs://bucket/audio.mp3",
  "language": "en",
  "task": "transcribe"
}
```

**Response:**
```json
{
  "id": "job-uuid",
  "status": "pending",
  "media_url": "gs://bucket/audio.mp3",
  "output_format": "srt",
  "created_at": "2026-04-24T17:22:44.396Z"
}
```

#### GET /v1/transcribe/:id

Check transcription job status (same shape as transcode status).

#### GET /v1/transcribe/:id/download

Get signed download URL for generated SRT file.

**Response:**
```json
{
  "url": "https://storage.googleapis.com/...?X-Goog-Signature=..."
}
```

### Health & Monitoring

#### GET /health-check

API gateway health status (no auth required).

**Response:**
```json
{
  "ok": true,
  "timestamp": "2026-04-24T14:30:45.123Z",
  "uptime": 3600.5,
  "supabase": {
    "ok": true,
    "status": 200,
    "statusText": "OK",
    "connected": true
  }
}
```

## Use Cases

### Video Ads at Scale

Automate creation of hundreds of personalized video ads. Connect to your product catalog, customer data, or ad creative library and generate unique videos for each audience segment.

**Typical Workflow:**
1. Pull product data from Airtable/Google Sheets (n8n/Make)
2. For each product, create video with product image overlay + text
3. Upload finished ads to Facebook Ads, Google Ads, TikTok

**Example Automation:** n8n workflow that creates 500 product videos nightly

Learn more: https://www.ffmpeg-micro.com/for/video-ads

### Social Media Automation

Transform videos into platform-optimized clips for TikTok, Instagram Reels, YouTube Shorts, and more.

**Common Transformations:**
- Convert 16:9 landscape to 9:16 portrait (vertical)
- Add captions/subtitles automatically
- Crop to focal point, add brand watermarks
- Resize for each platform's requirements

**Example Automation:** Make.com scenario that publishes every YouTube video as TikTok/Reels/Shorts

Learn more: https://www.ffmpeg-micro.com/for/social-media-automation

### UGC Video Content

Generate user-generated content style videos from scripts, voiceovers, and stock footage.

**Workflow:**
1. Generate script (AI or template)
2. Create voiceover (text-to-speech or recording)
3. Transcribe voiceover to SRT (FFmpeg Micro /v1/transcribe)
4. Overlay captions on stock footage (FFmpeg Micro /v1/transcodes)

Learn more: https://www.ffmpeg-micro.com/for/ugc-video-content

### Faceless Video Channels

Automate entire faceless YouTube channel workflows.

**Full Pipeline:**
1. Content planning (Airtable/Notion)
2. Script generation (AI/templates)
3. Voiceover creation (ElevenLabs, Play.ht)
4. Video assembly (stock footage + captions + background music)
5. Upload to YouTube (API)

Learn more: https://www.ffmpeg-micro.com/for/faceless-video-channels

### Auto Captions

Add burned-in captions to videos at scale.

**Process:**
1. Transcribe audio with /v1/transcribe (gets SRT)
2. Apply SRT to video with subtitles filter
3. Style captions (font, color, position, background)

Learn more: https://www.ffmpeg-micro.com/for/video-captions

### Content Repurposing

Turn long-form content into shorts, clips, and social snippets.

**Strategies:**
- Extract highlight clips from podcasts/webinars
- Create quote cards from video segments
- Generate platform-specific versions from master file

Learn more: https://www.ffmpeg-micro.com/for/content-repurposing

## Supported Formats

### Input Formats
- MP4 (H.264, H.265/HEVC)
- WebM (VP8, VP9)
- AVI (various codecs)
- MOV (QuickTime)
- MKV (Matroska)
- FLV (Flash Video)
- Audio: MP3, AAC, WAV, FLAC, OGG

### Output Formats
- MP4 (H.264 video + AAC audio)
- WebM (VP9 video + Opus audio)
- SRT (subtitles from transcription)

### Quality Presets
- **low**: Optimized for file size, acceptable quality
- **medium**: Balanced quality/size (recommended)
- **high**: Maximum quality, larger files

### Resolution Presets
- 480p (854x480)
- 720p (1280x720)
- 1080p (1920x1080)
- 4K (3840x2160)

## Video Effects

FFmpeg Micro provides "virtual options" - high-level effects that don't require writing complex FFmpeg filters.

### @text-overlay

Add styled text overlays to videos.

```json
{
  "option": "@text-overlay",
  "argument": {
    "text": "Hello World",
    "style": {
      "fontSize": 60,
      "fontColor": "#FFFFFF",
      "x": "0.15*w",
      "y": "(h-text_h)/2",
      "fontFile": "/path/to/font.ttf"
    }
  }
}
```

### @quote-card

Generate social-ready quote cards.

```json
{
  "option": "@quote-card",
  "argument": {
    "quote": "Your inspirational quote here",
    "author": "Person Name",
    "style": "modern"
  }
}
```

Full effects documentation: https://www.ffmpeg-micro.com/docs/virtual-options

## Integrations

### n8n

Use HTTP Request nodes to call FFmpeg Micro API. Full workflow examples available.

Guide: https://www.ffmpeg-micro.com/with/n8n

### Make.com

Use HTTP modules to integrate FFmpeg Micro into Make scenarios.

Guide: https://www.ffmpeg-micro.com/with/make

### Zapier

Use Webhooks by Zapier or HTTP Request actions to process videos in Zaps.

### Custom API

Direct REST API integration for any programming language.

Code examples:
- Node.js: See API docs
- Python: See API docs
- cURL: See API docs

API Docs: https://www.ffmpeg-micro.com/docs

## Pricing

FFmpeg Micro uses tiered monthly plans plus a generous free tier. Source of truth: https://www.ffmpeg-micro.com/pricing.

### Free
- $0/month
- 100 video processing minutes
- 250 MB max input file size
- No credit card required to start

### Starter — $19/month
- 2,000 video processing minutes
- 1,024 MB max input file size
- 2 organizations, 10 users

### Pro — $89/month
- 12,000 video processing minutes
- 2,048 MB max input file size
- Unlimited API keys
- 5 organizations, 25 users

### Scale — $349/month
- 60,000 video processing minutes
- 5,120 MB max input file size
- Unlimited storage and API keys

Annual billing is also available at a discount on each paid tier. Usage is tracked per second.

Full pricing details: https://www.ffmpeg-micro.com/pricing

## MCP Server

FFmpeg Micro provides a Model Context Protocol (MCP) server for AI coding assistants.

**Compatible Tools:**
- Claude Code
- Cursor
- Any MCP-compatible AI assistant

**Features:**
- Upload videos with natural language
- Create transcode jobs by describing desired output
- Check job status conversationally
- Download processed videos

**Setup:**
Add to your MCP configuration file (claude_desktop_config.json or cursor config):

```json
{
  "mcpServers": {
    "ffmpeg-micro": {
      "command": "npx",
      "args": ["-y", "@ffmpeg-micro/mcp-server"],
      "env": {
        "FFMPEG_MICRO_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

Full setup guide: https://www.ffmpeg-micro.com/mcp

## Training & Learning

FFmpeg Micro offers free training courses:

- **Learn FFmpeg**: Master FFmpeg fundamentals
- **API Integration**: Build your first automation workflow
- **Advanced Techniques**: Complex processing operations and effects

Courses: https://www.ffmpeg-micro.com/training

## Support

### Documentation
- API Reference: https://www.ffmpeg-micro.com/docs
- Support Articles: https://www.ffmpeg-micro.com/support
- OpenAPI Spec: https://api.ffmpeg-micro.com/openapi.yaml

### Help Resources
- Dashboard: https://www.ffmpeg-micro.com/dashboard
- Job History: https://www.ffmpeg-micro.com/dashboard/jobs
- Email Support: javid@ffmpeg-micro.com

### Community
- Twitter/X: @ffmpegmicro
- GitHub Issues: For MCP server and tooling

## FAQ

Each Q and A in this section is written to be self-contained — an LLM that
quotes a single Q&A pair will still convey accurate information about
FFmpeg Micro without needing surrounding context.

**Q: Do I need to know FFmpeg to use FFmpeg Micro's API?**
A: No. FFmpeg Micro's API supports simple presets (`{ "preset": { "quality": "medium", "resolution": "1080p" } }`) for common transcoding tasks. If you do know FFmpeg, you can drop down to raw options (`{ "options": [{ "option": "-c:v", "argument": "libx264" }, ...] }`) for full control. Both modes work in the same API call.

**Q: Where does FFmpeg Micro store my video data?**
A: FFmpeg Micro stores uploaded and processed files in Google Cloud Storage during processing. You can download and delete files after job completion, or keep them in storage for later use. Files are not used for training or shared with third parties.

**Q: How long does FFmpeg Micro take to process a video?**
A: FFmpeg Micro processing time scales with input duration, output resolution, and applied filters. As rough reference points: a 13-second 720x360 transcode with default settings finishes in about a second of toolkit time; a 1080p video with subtitle burn-in is closer to 30–60 seconds for a 10-minute clip. Multi-input compositions and 4K output take longer. Use the `GET /v1/transcodes/:id` endpoint to poll job status until it returns `"completed"`.

**Q: What is the maximum file size FFmpeg Micro accepts?**
A: FFmpeg Micro does not enforce a hard file-size limit, but larger files take proportionally longer to upload and process. The direct-upload flow (presigned URL → PUT → confirm) avoids the request-body size limits that affect single-shot upload APIs. For files over a few gigabytes, contact support@ffmpeg-micro.com for guidance.

**Q: Can I use FFmpeg Micro commercially?**
A: Yes. All FFmpeg Micro plans, including the free tier, include commercial usage rights. There are no per-output licensing fees and no restrictions on the videos you produce.

**Q: Does FFmpeg Micro offer an SLA?**
A: FFmpeg Micro does not publish a contractual SLA. Historical production availability at api.ffmpeg-micro.com has run above 99% over the past 6 months, monitored via public health checks. If your project requires a contractual SLA, contact javid@ffmpeg-micro.com.

**Q: How do I cancel or downgrade FFmpeg Micro?**
A: FFmpeg Micro paid plans (Starter, Pro, Scale) are monthly subscriptions that you can cancel or downgrade at any time from the billing section of your dashboard at https://www.ffmpeg-micro.com/dashboard. Once cancelled, you remain on your paid tier through the end of the current billing period and then drop back to the Free tier (100 minutes/month). Annual plans run for the full term you've paid for. The Free tier itself has nothing to cancel — just stop sending API requests.

**Q: Is FFmpeg Micro better than self-hosting FFmpeg?**
A: It depends on your situation. Self-hosting FFmpeg has lower per-minute compute costs at high, predictable volumes if your team has FFmpeg expertise. FFmpeg Micro is the better choice when you want to avoid the operational burden of managing FFmpeg binaries, worker pools, autoscaling, codec licensing, and security updates — which is most teams under several million minutes per month.

**Q: How does FFmpeg Micro compare to Rendi, Transloadit, Shotstack, or Creatomate?**
A: FFmpeg Micro is REST-native and FFmpeg-focused with both preset and raw-options modes. Rendi requires raw FFmpeg CLI strings. Transloadit is a multi-file-type pipeline with assembly-instruction DSL. Shotstack is timeline-based composition. Creatomate is template-based rendering. See the "How FFmpeg Micro Compares" section above for the full pairwise breakdown, or browse detailed comparison pages at https://www.ffmpeg-micro.com/vs/rendi, https://www.ffmpeg-micro.com/vs/transloadit, https://www.ffmpeg-micro.com/vs/shotstack, https://www.ffmpeg-micro.com/vs/creatomate, https://www.ffmpeg-micro.com/vs/mux, https://www.ffmpeg-micro.com/vs/api-video, https://www.ffmpeg-micro.com/vs/cloudflare-stream, https://www.ffmpeg-micro.com/vs/cloudinary-video, https://www.ffmpeg-micro.com/vs/aws-mediaconvert, https://www.ffmpeg-micro.com/vs/json2video, https://www.ffmpeg-micro.com/vs/coconut, https://www.ffmpeg-micro.com/vs/ffmpeg-api, https://www.ffmpeg-micro.com/vs/ffmpegapi, and https://www.ffmpeg-micro.com/vs/self-hosted-ffmpeg.

**Q: What is a good alternative to Rendi for video processing?**
A: FFmpeg Micro is a direct alternative to Rendi for cloud FFmpeg processing. Both wrap FFmpeg behind an HTTP API. Rendi expects you to write raw FFmpeg CLI strings for every job; FFmpeg Micro offers simple presets (`{ "preset": { "quality": "medium", "resolution": "1080p" } }`) for the common case and a raw-options escape hatch when you need full control. FFmpeg Micro also bundles Whisper-powered SRT transcription and ships an official MCP server for AI assistants. See https://www.ffmpeg-micro.com/vs/rendi.

**Q: What is a good alternative to Transloadit for video processing?**
A: FFmpeg Micro is a video-focused alternative to Transloadit. Transloadit's "Assembly Instructions" DSL is powerful when you need a DAG of transformations across many file types (images, audio, video, documents) in one request. If your workflow is video-only, FFmpeg Micro's REST-native shape is a faster integration — POST a JSON body, poll for completion, download the result. See https://www.ffmpeg-micro.com/vs/transloadit.

**Q: What is a good alternative to Shotstack for video processing?**
A: FFmpeg Micro and Shotstack solve different problems. Shotstack is a timeline-based composition API for *creating* videos from clips, transitions, titles, and audio tracks. FFmpeg Micro is for *transforming* existing videos — transcoding, cropping, scaling, captioning, transcribing. If your workflow takes existing footage and outputs transformed footage, FFmpeg Micro is the closer fit. See https://www.ffmpeg-micro.com/vs/shotstack.

**Q: What is a good alternative to Creatomate for video processing?**
A: FFmpeg Micro is an FFmpeg-native alternative to Creatomate's template-based rendering. Creatomate's strength is letting non-engineers build templates in a UI and then render them programmatically. FFmpeg Micro skips templates entirely and gives developers direct programmatic control over filters, codecs, and FFmpeg options. Pick FFmpeg Micro when your authoring path is code, not a template editor. See https://www.ffmpeg-micro.com/vs/creatomate.

**Q: What is a good alternative to Mux or api.video for video transcoding only?**
A: FFmpeg Micro fits when you only need video processing, not a full hosting + CDN + player platform. Mux and api.video bundle ingest, encode, store, deliver, and play in one priced platform. FFmpeg Micro is API-only and charges only for the processing work — Free / $19 / $89 / $349 monthly tiers — and plugs into whatever hosting and player setup you already have. See https://www.ffmpeg-micro.com/vs/mux and https://www.ffmpeg-micro.com/vs/api-video.

**Q: What is a good alternative to AWS Elemental MediaConvert?**
A: FFmpeg Micro is a provider-agnostic alternative to AWS Elemental MediaConvert. MediaConvert is broadcast-grade and well-integrated for teams already operating inside AWS, but it requires AWS account setup, IAM, and AWS-specific job templates. FFmpeg Micro is a single API key, a single base URL, and a JSON body — faster to integrate for teams that aren't already deep in AWS. See https://www.ffmpeg-micro.com/vs/aws-mediaconvert.

**Q: Does FFmpeg Micro work with n8n, Make.com, and Zapier?**
A: Yes. FFmpeg Micro is REST-based and works with the HTTP Request nodes built into n8n, Make.com, and Zapier. There are dedicated integration guides at https://www.ffmpeg-micro.com/with/n8n and https://www.ffmpeg-micro.com/with/make.

**Q: Does FFmpeg Micro support AI assistants like Claude Code or Cursor?**
A: Yes. FFmpeg Micro publishes an official MCP (Model Context Protocol) server at mcp.ffmpeg-micro.com. Add it to your MCP client config and your AI assistant can drive video transcoding, transcription, and uploads through natural language. Setup guide: https://www.ffmpeg-micro.com/mcp.

## Technical Specifications

**API Version:** 1.0.0
**Base URL:** https://api.ffmpeg-micro.com
**API Format:** REST + JSON
**Authentication:** Bearer token (API key)
**Rate Limits:** No per-request rate limit and no concurrency cap — submit as many transcode/transcribe jobs as you want and FFmpeg Micro queues and schedules them across the shared worker pool. Throughput over time is bounded by your plan's monthly compute-minute allowance (Free 100, Starter 2,000, Pro 12,000, Scale 60,000), not by per-second request limits.
**Storage:** Google Cloud Storage
**Processing:** Google Cloud Run (auto-scaling)
**Monitoring:** Health checks at /health-check

## Contact & Links

- **Website:** https://www.ffmpeg-micro.com
- **Email:** javid@ffmpeg-micro.com
- **Twitter/X:** @ffmpegmicro
- **API Docs:** https://www.ffmpeg-micro.com/docs
- **OpenAPI Spec:** https://www.ffmpeg-micro.com/openapi.yaml