Connect Make to ChatGPT: Automate Scenarios and Team Roles
Learn how to connect Make to ChatGPT using a managed MCP server. Automate scenario execution, debug incomplete runs, and manage team roles using AI agents.
If you need to connect Make to ChatGPT to automate scenario execution, manage team roles, or orchestrate complex workflow deployments, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Make's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.
If your team uses Claude, check out our guide on connecting Make to Claude or explore our broader architectural overview on connecting Make to AI Agents.
Giving a Large Language Model (LLM) read and write access to a powerful automation platform like Make is a massive engineering challenge. You have to handle hierarchical data models, map dynamic module configurations to MCP tool definitions, and deal with complex execution states. Every time a developer updates a scenario blueprint in Make, your custom server code must be updated, redeployed, and tested.
This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Make, connect it natively to ChatGPT, and execute complex workflows using natural language.
The Engineering Reality of the Make API
A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Make's highly specific API is exceptionally painful.
If you decide to build a custom MCP server for Make, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Make:
The Hierarchical Scoping Nightmare
Make's API is heavily nested. A user belongs to an Organization, which contains Teams, which contain Scenarios and Connections. If an LLM wants to list scenarios, it can't just call GET /scenarios. It must provide either a teamId or an organizationId—but never both. Your MCP server must inject the correct organizational context into the LLM's prompts, or the model will hallucinate query parameters and receive 400 Bad Request errors.
Blueprint Complexity and Module Data
A Make scenario isn't just a script; it is represented internally as a "blueprint"—a deeply nested JSON object detailing every module, trigger, router, and variable mapping on the canvas. If you want an AI agent to analyze why a scenario failed, it must fetch the incomplete execution (the DLQ), fetch the scenario blueprint, and map the failing module_id back to the canvas. Exposing this through a static schema to an LLM usually results in context window bloat and token limit errors unless the API responses are carefully standardized.
Buildtime vs. Runtime Variables
When automating configuration across Make teams, you must deal with Make's specific prefixing rules for buildtime variables. Team-defined variables must be prefixed with TAC_, while user-defined variables require PAC_. If your AI agent attempts to create a variable without understanding this strict upstream validation rule, Make rejects the payload. Writing custom instruction logic into your MCP server to enforce vendor-specific naming conventions is tedious and fragile.
How to Generate and Connect a Make MCP Server
Instead of building a custom Express app to handle Make's OAuth, pagination, and blueprint schemas, you can use Truto to generate a production-ready MCP server in minutes.
Truto automatically derives tool definitions from Make's API documentation and your configured integration resources. Here is how to configure the server and connect it to ChatGPT.
Step 1: Create the Make MCP Server
You can generate an MCP server scoped to a specific Make account using either the Truto Dashboard or the API. Both methods output a secure, cryptographic URL (e.g., https://api.truto.one/mcp/<token>).
Method A: Via the Truto UI
- In the Truto dashboard, navigate to the Integrated Accounts page and select your connected Make account.
- Click the MCP Servers tab.
- Click Create MCP Server.
- Configure your server: Give it a name (e.g., "Make ChatGPT Server"), select allowed methods (e.g.,
read,write), and select allowed tags (e.g.,scenarios,teams). - Click Save and copy the generated MCP server URL.
Method B: Via the Truto API
If you are provisioning infrastructure programmatically, you can generate the server via a single POST request. This is ideal for multi-tenant AI platforms that need to spin up isolated Make servers for different customers.
curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
-H "Authorization: Bearer $TRUTO_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"name": "Make IT Automation MCP",
"config": {
"methods": ["read", "write", "custom"],
"tags": ["scenarios", "teams", "users", "incomplete_executions"]
},
"expires_at": "2026-12-31T23:59:59Z"
}'The response returns your server URL. This single URL handles routing, schema discovery, and authentication. Treat it like a secret.
Step 2: Connect the MCP Server to ChatGPT
Once you have your Truto MCP URL, you must register it with your LLM client.
Method A: Via the ChatGPT UI If you are using ChatGPT Pro, Plus, Enterprise, or Education:
- Open ChatGPT and navigate to Settings.
- Go to Apps -> Advanced settings and ensure Developer mode is enabled.
- Under the Custom Connectors / MCP servers section, click Add new server.
- Enter a name (e.g., "Make Automation").
- Paste your Truto MCP URL into the Server URL field and save.
ChatGPT will immediately perform an MCP handshake, call tools/list, and register all allowed Make endpoints as callable functions.
Method B: Via Manual Config File (SSE Transport) If you are orchestrating ChatGPT via an API-driven agent framework (like LangChain or AutoGen) or using a local dev client, you can connect using the standard MCP Server-Sent Events (SSE) proxy configuration:
{
"mcpServers": {
"make_automation": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sse",
"--url",
"https://api.truto.one/mcp/a1b2c3d4e5f67g8h9i0j"
]
}
}
}Hero Tools for Make
When you connect Truto's MCP server to ChatGPT, it automatically exposes Make's API as semantic, JSON Schema-backed tools. Here are the highest-leverage tools for automating Make.
1. Run a Scenario (make_scenarios_run)
This tool forces an active Make scenario to execute immediately. If the scenario expects a webhook payload, the LLM can construct and pass the required inputs dynamically.
"Trigger the 'Lead Routing' scenario. I need you to pass a JSON payload with
source: 'chatgpt'andlead_score: 95into the scenario inputs."
2. List Scenarios (list_all_make_scenarios)
Retrieves all scenarios within a specific Team or Organization. Crucial for discovery when the LLM needs to find a scenario ID before taking action.
"List all the scenarios in the 'Marketing Ops' team. Find the one responsible for Slack notifications and tell me its ID and whether it's currently active."
3. Retry Incomplete Executions (make_incomplete_executions_retry)
Make's DLQ system captures failed runs as "incomplete executions." This tool allows ChatGPT to trigger a retry of a failed execution using the data from the original run.
"Find the incomplete execution
dlq_98765for the HubSpot Sync scenario and trigger a retry now that the API outage is resolved."
4. Update Team Variables (make_teams_update_variable)
Updates custom buildtime or runtime variables for a specific Make team. This is highly useful for rotating API keys or updating environment configurations across dozens of scenarios at once.
"Update the team variable named
TAC_SALESFORCE_ENVIRONMENTin teamteam_445to have the valueproduction."
5. Check Module Data (make_scenarios_check_module_data)
Verifies if a specific module within a scenario has its data correctly configured. Useful for automated health checks and auditing blueprints before activation.
"Check the module data for module
14in scenariosc_772. Does it have the required authentication parameters set?"
6. Update a Make User (update_a_make_user_by_id)
Modifies user records within Make. While passwords and emails require separate endpoints for security, this tool handles role assignments and general metadata updates.
"Update the user
usr_992to reflect their new title in their profile, and check if they have organization-wide admin access."
For a complete list of tools, schemas, and required parameters, visit the Make integration page.
Workflows in Action
Exposing individual tools is useful, but the real power of connecting Make to ChatGPT via MCP is orchestration. Because the LLM understands the schema of multiple endpoints, it can chain them together to solve complex operational problems.
Workflow 1: The Scenario DLQ Resolver
When a third-party API goes down, Make scenarios queue up failed runs. Instead of manually clicking through the Make UI to inspect and retry them, an IT Admin can ask ChatGPT to handle the backlog.
"We just had a 502 Bad Gateway issue with our CRM. Find all incomplete executions for the 'Lead Sync' scenario, identify which ones failed at the HTTP module, and retry them."
How the agent executes this:
list_all_make_scenarios: The agent searches for the 'Lead Sync' scenario by name to grab itsscenarioId.list_all_make_incomplete_executions: It queries the DLQ for that specific scenario to retrieve the failed runs.make_incomplete_executions_incomplete_log: It inspects the logs of the failed runs to confirm the error originated from the HTTP module.make_incomplete_executions_retry: It iterates over the validdlq_ids and triggers retries, informing the user of the success count.
sequenceDiagram
participant User
participant Agent as ChatGPT (MCP Client)
participant Truto as Truto MCP Server
participant Make as Make API
User->>Agent: "Retry failed runs for 'Lead Sync'"
Agent->>Truto: call list_all_make_scenarios
Truto->>Make: GET /scenarios
Make-->>Truto: { id: "sc_123", name: "Lead Sync" }
Truto-->>Agent: Result: sc_123
Agent->>Truto: call list_all_make_incomplete_executions(sc_123)
Truto->>Make: GET /scenarios/sc_123/dlqs
Make-->>Truto: [{ dlq_id: "dlq_99" }]
Truto-->>Agent: Result: 1 failed execution
Agent->>Truto: call make_incomplete_executions_retry(dlq_99)
Truto->>Make: POST /dlqs/dlq_99/retry
Make-->>Truto: 200 OK
Truto-->>Agent: Success
Agent-->>User: "Successfully retried the execution."Workflow 2: Automated Team Configuration
DevOps teams constantly rotate API credentials. Instead of manually opening the Make dashboard to update team variables, they can direct ChatGPT to push the changes globally.
"We just rotated our SendGrid API key. Update the team variable
TAC_SENDGRID_KEYto the new value across all teams in our primary organization."
How the agent executes this:
list_all_make_teams: The agent fetches all teams associated with the parent organization.make_teams_update_variable: For each team returned, the agent invokes this tool, passing theteam_id, thevariable_name(TAC_SENDGRID_KEY), and the new key value.make_teams_history_custom_variable_updates: (Optional) The agent verifies the update by checking the variable history to ensure the diff shows the new key.
Security and Access Control
Exposing an enterprise automation platform like Make to an AI agent requires strict guardrails. Truto's MCP architecture provides multiple layers of security to ensure ChatGPT only has access to what it strictly needs.
- Method Filtering: You can configure the MCP token to only allow
readoperations. If a user asks ChatGPT to delete a scenario, Truto blocks the request at the tool generation phase—the LLM won't even know thedeletetool exists. - Tag Filtering: Restrict the server to specific domains. By applying a
scenariostag filter, the agent can run and list scenarios but cannot interact with users, teams, or billing data. - Extra Authentication (
require_api_token_auth): For high-security environments, possession of the MCP URL isn't enough. By enabling this flag, the client must also pass a valid Truto API token in theAuthorizationheader. - Time-to-Live (
expires_at): Generate temporary MCP servers for contractors or short-lived agent sessions. Once the expiration time hits, Truto's Durable Object alarms automatically destroy the server credentials. - Rate Limit Handling: Truto does not retry, throttle, or apply backoff on rate limit errors. If Make returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit info into standardized headers (
ratelimit-limit,ratelimit-remaining,ratelimit-reset) per the IETF spec. The AI agent (or the orchestrating client) is entirely responsible for interpreting these headers and executing its own backoff logic.
Connect Make to Your AI Agents Today
Building a custom MCP server for Make means wrestling with complex organizational hierarchies, nested blueprint schemas, and strict variable prefixes. By leveraging Truto, you bypass the boilerplate and instantly give ChatGPT secure, semantic access to Make's underlying API.
Whether you are debugging incomplete executions in a DLQ, orchestrating global team variables, or triggering automated workflows via chat, a managed MCP server scales effortlessly alongside your LLM usage.
FAQ
- How do I connect Make to ChatGPT?
- You can connect Make to ChatGPT by generating a Model Context Protocol (MCP) server URL via Truto. This URL is added as a Custom Connector in ChatGPT's Developer settings, instantly exposing Make's API endpoints as callable AI tools.
- Can ChatGPT run Make scenarios?
- Yes. By exposing the `make_scenarios_run` endpoint via MCP, ChatGPT can trigger active Make scenarios and pass required input data directly through the tool call.
- How does Truto handle Make API rate limits?
- Truto does not retry, throttle, or apply backoff on rate limit errors. If Make returns an HTTP 429, Truto passes that error to ChatGPT and normalizes the upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller is responsible for retry and backoff logic.
- Can I restrict what ChatGPT can do in Make?
- Yes. You can filter the auto-generated MCP tools by method (e.g., read-only) or by tags (e.g., only scenarios and teams). You can also enforce API token authentication and set expiration dates on the MCP server.