Make ChatGPT Plugin Tutorial: Build, Run, and Review Automations Inside ChatGPT

Introduction

The Make ChatGPT plugin turns a chat window into a control room for your automations. Instead of opening the Make builder to check a scenario, you describe what you want in plain language, run a scenario on demand, and review what it did, all without leaving the conversation. This tutorial is for Make users who already have scenarios, or want their first one, and who spend their working day in ChatGPT. You will connect Make to ChatGPT, run your first scenario from chat, and learn the limits that decide when to stay in chat and when to open the Make builder instead.

Quick answer

Add Make as a ChatGPT plugin with the MCP server URL https://mcp.make.com/v2, sign in with Make, then describe the automation you want in chat, run it on demand, and review its execution history in Make.

Evidence

Make’s own documentation draws the architecture clearly. The plugin entry in ChatGPT is backed by the Make MCP server, a Make-hosted, cloud-based server that runs over Streamable HTTP and exposes your scenarios to AI clients as callable tools. That is why the automations keep running after you close the chat window: ChatGPT is the remote control, Make is the engine.

Two numbers from that same documentation set expectations before you start. First, scenario run tools are available on all Make plans, including Free, while management tools that view or modify scenarios, connections, and teams require a paid plan, so Free users can run automations from chat but cannot manage them there. Second, MCP tool calls time out: a scenario run over the OAuth connection returns after 25 seconds, and a management call after 30 seconds, even though the scenario itself continues running in Make for up to 40 minutes. The timeout response includes an executionId that can retrieve the output later, which is the mechanism behind the “it timed out but still ran” behavior you will meet in the troubleshooting section.

Make’s community guide states the promise in one sentence, and it is worth quoting exactly because it defines the boundary of the feature: “Describe the outcome you need, then build, run, and review automations and AI agents without leaving the conversation.” Note what the sentence does not promise: it does not say the conversation replaces the builder. Your existing connections, permissions, scheduling, retries, and error handling stay in Make, according to the same guide to connecting Make to ChatGPT and Codex, and that is where you should verify anything the chat drafts before it touches real data.

The timing is also favorable. Make’s ChatGPT connection works from any ChatGPT plan, including Free personal accounts, per the same community guide. Meanwhile, OpenAI’s DevDay on September 29, 2026 pushed plugins deeper into ChatGPT with sidebar homes, interactive panels, and event-driven automations, and TechCrunch’s DevDay coverage put ChatGPT at 1.2 billion weekly users. A plugin that lives where that many people already work is worth setting up even if you only use it to run and review, not to build.

Prerequisites

• A Make account, on any plan including Free. A Free plan is enough to run scenarios from chat.
• A ChatGPT account, on any plan including Free. The web path below needs Developer Mode in ChatGPT settings.
• At least one Make scenario, ideally one set to run on demand, so you have something to run in step 4. If you have none yet, the build step below creates one, but verify it in the Make builder before activating it.
• A browser for the OAuth sign-in, and, for the desktop path, the ChatGPT desktop app.

Step-by-step guide

Step 1: Connect Make in ChatGPT on the web

Open ChatGPT on the web and click your profile in the lower-left corner. Open Settings, go to “Security and login”, and enable Developer Mode. This is the switch that allows adding a custom MCP connector, and without it the plugin form will not accept a server URL.

Next, visit the Plugins page, select Browse plugins, and click the Add icon in the top-right corner. Fill in the form exactly as follows:

• Name: Make
• Description: Build automations and AI agents (optional)
• Connection: Server URL
• Server URL: https://mcp.make.com/v2
• Authentication: OAuth

Select “Sign in with Make”, log in to your Make account in the browser window that opens, and approve the connection. You will be redirected to the Make plugin page, which confirms the connection is ready. Start a new chat, and the Make connection is live.

One detail matters for later troubleshooting: the server URL for the OAuth path is https://mcp.make.com/v2, with no zone and no API key in it. The zone-based URLs on the developer docs, such as https://eu2.make.com/mcp/v2, belong to the API key connection method, not to this plugin form. Mixing the two is the most common cause of a failed sign-in.

Step 2: Connect Make in the ChatGPT desktop app

If you use the desktop app, the path is shorter because the app has a native MCP section. Open ChatGPT settings, find the MCP section, and select “Add MCP server”. Enter these values:

• Name: Make
• Type: Streamable HTTP
• URL: https://mcp.make.com/v2

Save the server, then find the new Make connection in the MCP section and select Authenticate. A browser window opens for the Make sign-in. Choose the Make organization you want to connect, select Allow, and return to the app. The connection behaves exactly like the web plugin from here on: same tools, same timeouts, same plan limits.

Step 3: Connect Make in Codex from a terminal (optional)

Codex users get the same connection from the command line, which is handy if you already live in a terminal. Run these two commands:

codex mcp add make --url https://mcp.make.com/v2
codex mcp login make

A browser window opens. Sign in to Make, select your organization, and approve access. If you also want Codex to follow Make-specific building guidance, install Make Skills by downloading the skills archive, unzipping it, and copying the folders inside make-skills/skills/ to .codex/skills/ for one project or ~/.codex/skills/ for all projects, then restarting Codex. Skills are optional for ChatGPT itself, but in Codex they are what turns a vague “build me an automation” prompt into a scenario that follows Make’s own conventions.

Step 4: Run your first scenario from chat

Start a new chat and ask for something observable before you ask for anything destructive. Good first prompts, all taken from Make’s own guide, are:

• “List my Make scenarios.”
• “Explain what this scenario does.”
• “Run my on-demand scenario named [name] with [input].”

Watch for three things in the reply. First, ChatGPT should name the scenario it ran, not just claim success. Second, the output should come back into the chat, so you can reason over it and decide what to run next. Third, open the scenario in Make and confirm the execution appears in its history with the same time and result. That three-way match, chat claim, returned output, and Make execution history, is your proof the connection is real and not a hallucinated summary.

If the run takes longer than 25 seconds, ChatGPT will report a timeout. Do not re-run it immediately. Check the execution history in Make first: the scenario is still running there for up to 40 minutes, and re-running it can duplicate its side effects, such as sending a message twice or creating a duplicate record.

Step 5: Build a scenario from chat, then verify it in Make

Now try the build loop, with a deliberately small target. For example: “Build a Make automation that watches a Google Sheet for a new row and posts a summary to a Slack channel.” ChatGPT will draft the scenario through the MCP management tools, if your plan includes them, and describe the modules it chose.

Treat that draft as a proposal, not a finished automation. Open it in the Make builder and check four things before you activate it: the trigger module and its schedule, the connections on each module, the field mappings between modules, and the filter or router logic, if any. Fix anything wrong in the builder, run the scenario once manually from Make, and only then switch its schedule on. This verification step is where the chat workflow earns its keep: describing an automation in chat is fast, but a wrong mapping discovered after activation is expensive, and the builder is the only place you can see every mapping at once.

If you are on a Free plan, the build step will fail at the management tools, because those require a paid plan. That is expected, not a bug. Build the scenario in the Make builder yourself, set it to run on demand, and use ChatGPT for the run and review steps, which work on every plan.

Step 6: Review executions and manage from chat

The review loop is where the plugin saves the most time. Ask ChatGPT to “show my recent executions for [scenario name]” or “what did my last run return?” and compare the answer against the execution history in Make. When a run fails, ask what the error was, then fix the cause in Make: a revoked connection, a changed sheet column, or an expired token are the usual suspects, and none of them can be fixed from chat alone.

For a fuller picture of what the MCP connection can and cannot do, read our Make.com MCP Server tutorial, which covers OAuth versus token auth, scenario access control, and the timeout rules in depth. If you want to go further and have Make agents call other tools, the guide to connecting external MCP servers to a Make AI agent shows the reverse direction. And if you are weighing Make against other builders, the Complete n8n Guide compares the automation landscape from the n8n side.

Troubleshooting

ChatGPT has no Developer Mode or no plugin form

On the web, Developer Mode lives under Settings, then “Security and login”. If you cannot find it, check two things: you are on ChatGPT on the web, not inside a mobile app view, and your account is signed in. The desktop app does not need Developer Mode at all, since it has a native MCP section in settings, so switch to the desktop path in step 2 if the web path stays hidden.

Sign-in with Make loops or fails

First, confirm the server URL is exactly https://mcp.make.com/v2. A zone URL or a URL with an API key embedded belongs to a different connection method and will fail the OAuth flow. Second, complete the organization selection step: the browser window asks you to choose an organization and select Allow, and closing it early leaves a half-created connection that must be removed and re-added. Third, if you previously connected with an API key, remove the old connection from the MCP section before adding the OAuth one, so ChatGPT does not keep trying the stale credential.

A scenario run times out in chat but still completes in Make

This is the 25-second OAuth timeout working as documented, not a failure. The scenario keeps running in Make for up to 40 minutes. Do not run it again until you check the execution history in Make, or you risk duplicate side effects. If your scenario routinely exceeds 25 seconds, stop triggering it from chat and schedule it in Make instead, then use chat only to review its history. For the same reason, long-running scenarios should never send their final message or create their final record from a chat-triggered run alone: let the scheduled run own the side effect.

ChatGPT cannot edit or create scenarios

Management tools require a paid Make plan. On a Free plan, ChatGPT can list scenarios, explain them, and run on-demand scenarios, but view and modify operations are unavailable. If you are on a paid plan and management still fails, check the scopes you approved during sign-in: the connection only gets the tools its scopes allow, so re-authenticate and approve the management scopes. If you connected with an API key instead of OAuth, remember that key-based access can be restricted by organization, team, or scenario, and a key scoped to runs only will behave exactly like a Free plan connection.

ChatGPT builds a scenario with wrong mappings

This is the most expensive failure mode, because a wrong mapping can write bad data to a real system. Always open a chat-built scenario in the Make builder before activating it, and run it once manually from Make with test data. Pay special attention to field mappings between modules, since the chat description of a mapping (“use the email column”) can resolve to the wrong column when a sheet has several similar ones. If a scenario keeps coming back wrong, build the skeleton in the Make builder yourself, set it to on-demand, and use chat only to run it with different inputs.

FAQ

Three points deserve emphasis. First, connecting is free on both sides, but running is not free of cost: every chat-triggered run consumes the scenario’s normal Make operations, so a heavy agent loop can eat a monthly quota. Second, the direction matters: this plugin lets ChatGPT call Make, which is the reverse of adding an OpenAI module inside a Make scenario, and confusing the two is how people set up the wrong integration. Third, the timeout is a property of the connection, not a bug: a 25-second OAuth timeout means long scenarios belong on a Make schedule, with chat used to review their history, not to trigger them live.

Conclusion

The Make ChatGPT plugin is best understood as a remote control, not a replacement builder. Connect it once with the MCP server URL https://mcp.make.com/v2, use chat to list, explain, run, and review your scenarios, and do your building and verification in Make itself. That split gives you the speed of chatting without giving up the safety of seeing every mapping before it touches real data. Next, deepen the setup with our Make.com MCP Server tutorial, or try building a full agent in the guide to building next-gen Make AI agents in the scenario builder.

Frequently asked questions