Javid Jamae

Posted on Jul 10 • Originally published at ffmpeg-micro.com

FFmpeg MCP Server for VS Code: Process Videos with GitHub Copilot

#vscode #mcp #ffmpeg #githubcopilot

Originally published at ffmpeg-micro.com

VS Code now supports MCP servers through GitHub Copilot's agent mode. That means you can process video without leaving your editor. Tell Copilot to transcode a file, resize it for social, or extract audio, and it calls the FFmpeg Micro API directly. No terminal tab, no Postman, no remembering API parameters.

This guide covers setup in under 5 minutes and real examples of what you can do once it's connected.

Set up the FFmpeg Micro MCP server in VS Code

You need two things: a free FFmpeg Micro API key (grab one at ffmpeg-micro.com) and VS Code with GitHub Copilot installed.

Add the MCP server configuration

Open your VS Code settings JSON (Cmd+Shift+P > "Preferences: Open User Settings (JSON)") and add this block:

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

Replace your_api_key_here with your actual API key.

Verify the connection

Open the Copilot chat panel (Ctrl+Shift+I or Cmd+Shift+I on macOS) and switch to Agent mode using the dropdown at the top. You should see FFmpeg Micro listed under available tools. If it doesn't appear, restart VS Code and check that Node.js 18+ is installed (npx needs it).

You can also verify from the command palette: Cmd+Shift+P > "MCP: List Servers" should show ffmpeg-micro with a green status indicator.

What the MCP server gives you

Once connected, Copilot can call these tools on your behalf:

create_transcode converts video between formats, applies quality presets, or runs custom FFmpeg commands
get_transcode checks the status of a running job
list_transcodes shows your recent jobs
create_presigned_url gets an upload URL for local files
confirm_upload confirms a file landed in cloud storage
get_download_url gets a signed link to download completed output
transcribe_audio generates SRT subtitles using Whisper

You don't need to remember any of these. Just describe what you want in natural language.

Real examples: video processing from Copilot chat

Switch to Agent mode in the Copilot panel and try these prompts.

Convert MP4 to WebM:

"Convert this video to WebM at high quality: https://storage.example.com/demo.mp4"

Copilot calls create_transcode with the correct parameters, returns the job ID, and can check status when you ask "is it done yet?"

Resize for Instagram Reels:

"Resize this video to 1080x1920 vertical format: https://storage.example.com/landscape-clip.mp4"

The agent figures out it needs custom FFmpeg options for the scale filter and constructs the right request body.

Extract audio from a video:

"Extract just the audio from this MP4 as a WAV file: https://storage.example.com/interview.mp4"

Copilot uses the advanced options mode to pass -vn (no video) and sets outputFormat to the right container.

Batch process from a list:

"I have these 3 videos. Convert them all to MP4 at medium quality: [url1, url2, url3]"

The agent creates three separate transcode jobs and reports back their IDs. You can follow up with "check the status of all three" to see which ones have completed.

Add subtitles:

"Transcribe this video and give me the SRT: https://storage.example.com/tutorial.mp4"

Copilot calls transcribe_audio and returns the subtitle text directly in chat. You can save it to a file or ask follow-up questions about the content.

Workspace-level configuration

If you want the MCP server available only in a specific project (not globally), add the configuration to .vscode/mcp.json in your project root:

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

This reads the API key from your environment variable instead of hardcoding it. Set FFMPEG_MICRO_API_KEY in your shell profile or .env file.

How this fits into a development workflow

The MCP server isn't just for ad-hoc conversions. It slots into your workflow in practical ways:

During development: You're building a feature that handles video uploads. Instead of writing a test script, tell Copilot to process your test fixture and check the output format matches what your frontend expects.

Content creation: You're writing docs and need a quick demo video in WebM format. Process it from chat without context-switching.

Debugging: A user reports their video fails to transcode. Paste the URL into Copilot and ask it to try the transcode. You get immediate feedback on whether the issue is the file or your code.

CI/CD validation: Generate test assets from chat to validate your pipeline handles edge cases (different codecs, resolutions, durations).

Common pitfalls

Agent mode required. MCP tools only work in Copilot's Agent mode, not the default chat or inline completion modes. Switch the mode dropdown before asking video-related questions.
Node.js version matters. The MCP server requires Node.js 18 or higher. If npx fails silently, check your Node version with node --version.
Large files need upload first. If your video isn't at a public URL, you'll need to upload it first. Tell Copilot "I have a local file at /path/to/video.mp4 that I need to upload and convert" and it handles the presigned URL flow.
Job timeouts. Long videos (30+ minutes) can take several minutes to process. Copilot's chat doesn't auto-refresh, so ask "check the status" after a minute or two.

FAQ

Does this work with VS Code forks like Cursor or Windsurf?
Cursor and Windsurf have their own MCP configurations. The FFmpeg Micro MCP server works with all of them, but the setup location differs. Check the Cursor guide or Windsurf guide for those editors.

Is the MCP server free?
The server itself is open source and free to install. You need an FFmpeg Micro API key, which has a free tier (10 minutes of processing per month). Paid plans start at $19/month for higher volume.

Can I use this without GitHub Copilot?
You need GitHub Copilot for the agent mode that calls MCP tools. Without it, VS Code doesn't have a built-in way to invoke MCP servers interactively. If you use a different AI extension that supports MCP (like Continue or Cody), the same server configuration works.

What happens if the MCP server crashes?
VS Code shows an error indicator next to the server name in the MCP panel. Restart it from the command palette (Cmd+Shift+P > "MCP: Restart Server"). Your API key and config persist.

Can I see what API calls Copilot is making?
Yes. When Copilot calls an MCP tool, it shows the tool name and parameters in the chat before executing. You can approve or deny each call. This gives you full visibility into what's being sent to the FFmpeg Micro API.

Last verified: July 2026 against VS Code 1.100+ with GitHub Copilot agent mode

DEV Community