Cursor + FFmpeg Micro: Ship Video Features Without Learning FFmpeg

Use Cursor IDE with FFmpeg Micro's MCP server to add video processing to your app. No FFmpeg knowledge needed. Free tier available.

Originally published at ffmpeg-micro.com

You're building a product. Somewhere in the spec, there's a video feature: thumbnail generation, format conversion, maybe clip trimming. You don't want to learn FFmpeg to ship it. You shouldn't have to.

This post walks through connecting FFmpeg Micro's MCP server to Cursor so your AI assistant can write video processing code for you. No FFmpeg knowledge required.

The problem with video in MVPs

Video processing is the feature that kills momentum. You either spend days wrestling with FFmpeg flags and codec options, or you pay $200/month for an enterprise video API you don't need yet. Most founders just skip the video feature entirely.

That's the wrong tradeoff.

The video feature is often the thing that makes your product feel real. A course platform without video upload is a Google Doc. A social app without clip trimming is a text feed. Skipping video doesn't save time. It delays the moment your product becomes compelling.

The problem isn't that video processing is hard. It's that the tooling assumes you already know what you're doing. FFmpeg has over 400 flags. The documentation reads like a systems manual from 1998. And every Stack Overflow answer assumes you understand codecs, containers, and pixel formats.

You don't need to understand any of that to ship a video feature.

How Cursor + FFmpeg Micro works

FFmpeg Micro has an MCP (Model Context Protocol) server that exposes video processing tools to AI assistants. Cursor supports MCP natively. Once you connect the two, you can describe video operations in plain English and Cursor writes the integration code for you.

No FFmpeg docs. No Stack Overflow rabbit holes. Just tell Cursor what you want, and it calls the API.

The MCP server gives Cursor access to six tools: creating transcode jobs, checking job status, listing jobs, canceling jobs, getting download URLs, and a convenience tool that handles the full create-poll-download cycle in one shot. Cursor sees the tool descriptions, understands the parameters, and generates the right API calls for your codebase.

Setting it up (under 5 minutes)

1. Create a free account at ffmpeg-micro.com if you don't have one yet.

2. Add the MCP server to your project. Create a .mcp.json file in your project root:

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

3. Restart Cursor. It will detect the MCP server automatically. The first time it connects, a browser window opens for OAuth sign-in with your FFmpeg Micro account. After you approve, the token is cached and you won't be asked again.

That's it. No API keys to copy, no environment variables to configure. The FFmpeg Micro tools will appear in Cursor's tool panel.

If you prefer using an API key instead of OAuth (useful for CI or automation), you can grab one from your dashboard and pass it as a header:

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

Real examples

Once the MCP server is connected, you just talk to Cursor. It generates the API calls your app needs. Here are three common scenarios.

"Convert this user-uploaded video to MP4 with reasonable quality"

Tell Cursor what you need, and it generates something like this:

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: 'mp4',
    preset: { quality: 'high', resolution: '1080p' }
  })
});
const job = await response.json();

You didn't need to know that "reasonable quality" maps to a CRF of 18. Cursor figured that out from the MCP tool descriptions.

"Trim this video to the first 30 seconds for a preview"

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: 'mp4',
    options: [
      { option: '-ss', argument: '0' },
      { option: '-t', argument: '30' },
      { option: '-c', argument: 'copy' }
    ]
  })
});

The -ss, -t, and -c copy flags are standard FFmpeg. But you didn't write them. Cursor knew what "trim to 30 seconds" means in FFmpeg terms because the MCP server told it which options are available.

"Add a text overlay with the product name"

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: 'mp4',
    options: [
      {
        option: '@text-overlay',
        argument: {
          text: 'Built with Acme',
          style: { fontSize: 48, x: '(w-text_w)/2', y: 'h-80' }
        }
      }
    ]
  })
});

The @text-overlay virtual option handles all the drawtext filter complexity behind the scenes. If you've ever tried to write an FFmpeg drawtext command by hand, you know why this matters.

Each of these examples polls the job status and grabs a signed download URL when the transcode finishes. Cursor generates the polling logic too. You can also use the transcode_and_wait MCP tool during development to handle the full cycle in one call.

Why this beats learning FFmpeg

The comparison isn't really close.

Learning FFmpeg means weeks of reading docs, fighting codec compatibility issues, memorizing flags, and debugging cryptic error messages. Every new video feature means another research session.

Cursor plus FFmpeg Micro means you describe what you want, get working code, and ship today. The MCP server acts as a bridge between natural language and the API. Cursor doesn't guess at the integration. It has the full tool specification and generates correct calls.

You can always learn FFmpeg later when you need fine-grained control over encoding parameters or want to optimize for specific use cases. Right now, you need to ship.

And if you're already using VS Code with GitHub Copilot, the same MCP server works there too. You can also build autonomous video processing agents with Claude Desktop using the same setup.

FAQ

Do I need to know FFmpeg commands?

No. That's the whole point. Cursor's AI understands the FFmpeg Micro API through the MCP server. Describe what you want in plain English.

What does this cost?

FFmpeg Micro has a free tier. You pay per minute of video processed after that. Most MVPs process under an hour of video per month, which keeps costs minimal.

Can I use this with other IDEs?

The MCP server works with any MCP-compatible tool. Claude Desktop, VS Code with GitHub Copilot, Windsurf, Warp. FFmpeg Micro has setup guides for all of them.

What if I need something FFmpeg Micro doesn't support?

The API accepts raw FFmpeg options for advanced use cases. If it's a valid FFmpeg flag, you can pass it through the options array. The MCP server documents which flags are supported, so Cursor knows what's available.

FFmpeg Micro's free tier gives you enough processing for most MVP video features. Create an account, drop the MCP config into your project, and ship that video feature today.