process video from a ChatGPT conversation with Make MCP

You typed a request into ChatGPT, expected your Make scenario to fire, and found the Make plugin gone from the directory. MCP replaced it, and it works, but the first real video request you send through it fails for two reasons nobody writing about this connection mentions.

Quick answer: Make's ChatGPT plugin has been unavailable since September 2026, restored as a limited beta only for people who had already installed it, so the working Make MCP ChatGPT route is a custom connector: in ChatGPT Settings open Developer mode, add https://mcp.make.com as a Streamable HTTP server with OAuth, or https://eu2.make.com/mcp/u/<MCP_TOKEN> with No Auth, then approve your organization and scopes. For the video half of a request like "cut this to 9:16 and burn captions," a Make scenario full of modules blows past the MCP tool timeout, so send the render to FFmpeg Micro instead: one call to https://api.ffmpeg-micro.com/v1/transcodes returns a job ID immediately, and a second call polls it until the file is ready.

The plugin status, in Make's own words

Make's Feature Spotlight for the ChatGPT plugin, posted September 9, 2026 and updated September 29, still opens with "The Make plugin for ChatGPT is temporarily unavailable." OpenAI restored temporary beta access only for users who had previously installed it, the experience "may not work exactly as before," and the plugin stays unlisted in directory search. The same post names the alternative: "you can still connect Make to ChatGPT or Codex through MCP."

No restoration date has been published, and the plugin isn't dead either. It's a limited beta you probably can't join, while MCP is the path Make supports for everyone else.

Which Make MCP URL is the right one

Make documents three URL shapes for this same job across three pages, the fastest way to end up with a connector that authenticates and then does nothing. The shape you pick follows from how you authenticate, not from preference.

The token and toolbox routes buy roughly twice the tool timeout plus per-scenario scoping, which matters for anything touching media. Make's help center recommends the /stateless Streamable HTTP transport over /stream for reliability. Scenario-run tools work on all Make plans; management tools need a paid one.

Setting it up in ChatGPT Developer Mode

Developer Mode is an OpenAI beta granting full read and write MCP tool access, with a prompt before any action that modifies data. Custom connectors run on Plus, Pro, Business, Enterprise and Edu, not on ChatGPT Free, and Make's token-route docs require a paid ChatGPT subscription. Tools don't work inside shared chats.

That last step isn't ceremony. A Make MCP connector can authenticate and still never execute anything, with nothing in execution history. One Make community thread from February 2026 documents that on a paid Core plan and closes unresolved. The prerequisites are scattered across the replies: the scenario has to be active, exposed as an on-demand tool rather than behind a basic On Demand trigger, and described well enough that the model picks it. "Scenario 14" with no description is invisible even when the connection is perfect.

Why "cut this to 9:16 and burn captions" breaks

Once the connector works, the first interesting request is a media job, and the chat window hits two walls that have nothing to do with Make.

The first is the file. Video upload inside ChatGPT is inconsistent across plan, device and UI rollout, and fails on size limits and timeouts, so you can't assume an attachment will be there. The job needs a URL or a presigned upload. Transcript-first workarounds solve this for text, but the moment the request is about pixels (reframed to 9:16, captions burned in) a transcript is a dead end.

The second is time. MCP tool calls commonly time out around 60 seconds with error -32001, and Make's OAuth connections cut off at 25-30 seconds. A 90-second clip reframed and captioned is not a 25-second operation. The fix is the async job pattern: return a job ID in milliseconds, poll a second tool for status, then fetch the output. The shape you want isn't one giant Make scenario doing the render, it's a media tool that submits and a second call that checks.

Done by hand, the render is two steps and a local FFmpeg build:

# 1. transcribe (Whisper needs 16 kHz mono first)
ffmpeg -i input.mp4 -vn -ac 1 -ar 16000 -c:a pcm_s16le audio.wav
whisper audio.wav --model medium --output_format srt

# 2. crop to 9:16 and burn the captions in
ffmpeg -i input.mp4 -vf "crop=ih*9/16:ih,scale=1080:1920,\
subtitles=audio.srt:force_style='FontSize=18,Outline=2'" \
-c:v libx264 -preset medium -crf 20 -c:a aac out.mp4

That runs fine on your laptop. It doesn't run from a chat window, it doesn't run in Make, and nothing in ChatGPT can execute it. (The same gap is why n8n's Execute Command node going away pushed everyone's FFmpeg step onto HTTP.)

The same job as one API call

The API version is a submit and a poll, the exact shape an MCP tool call needs. Submit returns in well under a second:

curl -s -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer $FFMPEG_MICRO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{ "url": "gs://your-bucket/1234567890-upload.mp4" }],
    "outputFormat": "mp4",
    "preset": { "quality": "medium", "resolution": "1080p" }
  }'

{
  "id": "abc123-job-uuid",
  "status": "pending",
  "output_format": "mp4",
  "created_at": "2026-10-04T12:00:00Z"
}

Then GET /v1/transcodes/abc123-job-uuid until status is completed, and GET /v1/transcodes/abc123-job-uuid/download for a signed URL good for 10 minutes. Status checks, job listing and downloads are free; you're billed per second on the input video's duration, no rounding up to the minute, and failed jobs are never billed. For a file on someone's desktop, POST /v1/upload/presigned-url plus POST /v1/upload/confirm hands back a gs:// URL ready to use as an input. That's the presigned path the chat window needs.

As an MCP tool call, next to Make

You don't have to route the render through Make at all. FFmpeg Micro's MCP server at mcp.ffmpeg-micro.com sits in ChatGPT's connector list beside the Make one, authenticates with OAuth 2.1 and PKCE, and splits the async pattern into separate tools on purpose. transcode_video creates the job and returns an ID immediately, get_transcode fetches status, output URL and processing time, get_download_url mints the signed link. transcribe_audio and get_transcribe do the Whisper half, and request_upload_url plus confirm_upload solve the file problem in two tool calls.

One-shot transcode_and_wait and run_blueprint_and_wait variants exist, documented as the ones that break on long renders. Use them for a five-second GIF, not a captioned two-minute clip.

The division of labor that holds up: the model picks parameters (aspect ratio, hook text), Make handles the steps around the job (file source, output destination, notifications), and the encode lives behind a job API where a retry is idempotent and a timeout is a poll instead of a failure. That's the same reason a model swap wasn't enough after the Sora API shutdown: the reframe, stitch and caption steps have to be explicit somewhere, and an LLM is the worst place to put them.

Pitfalls that cost an afternoon

A mismatched URL and auth setting is the most common failure, and from the chat window it looks like every other one. The bare mcp.make.com host expects OAuth; the zone URL with a token in the path expects No Auth. Cross them and the connector lists zero tools.

An inactive scenario is second. Make scenarios must be switched on and exposed as on-demand tools before the model can call them, and a missing description means the model never picks the tool. Check execution history after every test: no entry means your request never reached Make.

Then the timeout. A request that works in the Make UI and dies in ChatGPT is the 25-30 second OAuth ceiling, not a broken scenario. Move the render into a submit-and-poll tool, or switch to the token route.

Long renders come back to Make as webhook callbacks, and a paused or erroring scenario silently piles those into a queue. Make shipped MCP tools on September 22, 2026 for listing queued deliveries, checking queue capacity and deleting items, on every plan including free. That's the first real visibility into the "my video finished but the scenario never ran" failure.

When this is the wrong shape

A chat window is a terrible trigger for volume. At 200 clips a night, the chat is a debugging surface at best and the work belongs on a scheduled Make scenario or a direct API loop. If your job is template-driven social graphics with a designer editing layouts, a template-editor product fits better than a media API. And if you want a timeline and a scrubber, you want an editor; FFmpeg Micro has no editing UI.

If OpenAI restores the plugin fully, you do nothing. The plugin and an MCP connector are separate surfaces, and the media tool call never depended on Make's ChatGPT integration.

FAQ

Do I need a paid ChatGPT plan to use Make MCP?

A paid ChatGPT plan is required. Developer Mode custom connectors run on Plus, Pro, Business, Enterprise and Edu, and Make's token-route docs say the same. ChatGPT Free cannot add custom connectors at all.

Why does my Make MCP connector authenticate but never run a scenario?

A Make MCP connector that authenticates without executing anything usually has an inactive scenario, one that isn't exposed as an on-demand tool, or no description for the model to match against. A February 2026 Make community thread reports this on a paid Core plan with nothing in execution history; the fix in the replies is a Scenarios "Start a Scenario" module plus a description.

How do I give ChatGPT a video file to process?

Pass a URL rather than an attachment. Video upload inside ChatGPT varies by plan, device and interface version, so a working pipeline uses a public or signed URL, or a presigned upload: request_upload_url for a PUT target, confirm_upload to finalize, then the returned gs:// URL as the job input.

What happens when a video render takes four minutes?

A four-minute render exceeds every MCP tool timeout, so the job has to be submitted and polled rather than awaited. transcode_video returns a job ID in milliseconds and get_transcode reports status on each later call, keeping every tool call inside the 25-60 second window no matter how long the encode runs.

Does the same MCP setup work from Claude or Cursor?

The FFmpeg Micro MCP server works from any MCP-compatible client, including Claude Code, Claude Desktop, Cursor, Windsurf and VS Code, with the same OAuth flow and tools. Moving from ChatGPT to Claude is a config entry, not a rebuild.

If you want the Make side built for you, the five FFmpeg Make scenarios are free one-click templates on the official Make app, and a free FFmpeg Micro account gets you 200 tokens with no card, enough for about 33 minutes of video to test the submit-and-poll loop end to end.