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"
    }
  }
}
  1. 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' }
    ]
  })
});

Cursor translated “first 30 seconds” into the correct -ss, -t, and -c copy flags — the kind of FFmpeg incantation that typically requires a Stack Overflow detour to get right.

With the MCP server connected, describing your video requirements in plain English is enough. Cursor handles the translation into working API calls, so you can ship the video feature and move on.