Overview

This MCP (Model Context Protocol) server bridges Make scenarios and AI assistants by exposing your on-demand Make automations as callable tools. The server connects to a Make account, discovers scenarios configured with “On‑Demand” execution, surfaces their input parameters and descriptions, and provides an MCP-compatible surface so AI systems can list, invoke, and receive structured JSON results from those scenarios.

A modern cloud-based version of this server is available and recommended for most use cases (see Resources below). The cloud-hosted variant reduces operational overhead, improves reliability, and keeps the MCP endpoint up to date. Use the self-hosted Node package when you need local control or to integrate with a custom runtime (for example during development or when running inside a specific environment).

Features

Discovers Make scenarios that are set to “On‑Demand”
Parses scenario input parameters and exposes human-friendly descriptions for AI assistants
Invokes scenarios programmatically with typed parameters
Returns scenario outputs as structured JSON for reliable machine consumption
Compatible with MCP clients (e.g., Claude Desktop) and other MCP-aware assistants
Easy to run locally via npx or deploy cloud-hosted for production reliability

Installation / Configuration

Prerequisites:

Node.js (for local/self-hosted runs) or use the cloud-hosted server (recommended)
Make API key with appropriate scopes
An MCP client (optional, e.g., Claude Desktop) to consume the server

Required Make API scopes:

Scope	Purpose
scenarios:read	Discover scenario definitions and input parameters
scenarios:run	Trigger scenario execution

Run locally with npx:

# Run once with environment variables
MAKE_API_KEY="<your-api-key>" MAKE_ZONE="eu2.make.com" MAKE_TEAM="<team-id>" npx -y @makehq/mcp-server

Example Claude Desktop configuration (add to claude_desktop_config.json → mcpServers):

{
  "mcpServers": {
    "make": {
      "command": "npx",
      "args": ["-y", "@makehq/mcp-server"],
      "env": {
        "MAKE_API_KEY": "<your-api-key>",
        "MAKE_ZONE": "<your-zone>",
        "MAKE_TEAM": "<your-team-id>"
      }
    }
  }
}

Environment variable notes:

MAKE_API_KEY — create this in your Make profile (ensure the two scopes above are enabled)
MAKE_ZONE — the Make region/host for your organization (for example: eu2.make.com)
MAKE_TEAM — team ID; often visible in the URL when you view your team in the Make UI

Security tip: store API keys in your platform’s secret manager rather than plain text configuration files.

Available Resources

Official cloud-hosted MCP server docs: https://developers.make.com/mcp-server
GitHub repository (self-hosted implementation): https://github.com/integromat/make-mcp-server
Make API documentation: https://www.make.com/en/developer (check the API and scopes sections)
MCP (Model Context Protocol) client examples: Claude Desktop and other MCP-aware tools

Available Tools / Exposed Capabilities

When connected, the MCP server will expose:

A list of callable tools representing each “On‑Demand” scenario, including parameter names, types, and descriptions
Invocation capability so an MCP client can run a scenario with validated inputs
Structured JSON output from scenarios suitable for downstream processing by an AI assistant

Specific endpoint or protocol details follow the MCP specification; clients that implement MCP can discover and use the server automatically.

Use Cases

AI assistant triggers invoicing workflow: An assistant gathers invoice data from the user, calls the Make scenario exposed via MCP to generate and send the invoice, and returns the Make scenario result (success, invoice URL, or error details) back to the user.
Customer support automation: A bot extracts a support ticket summary from a conversation, invokes a Make scenario to create a ticket in your system, and relays the ticket ID and status to the user.
Data enrichment and reporting: An AI orchestrates data pulls across services by invoking different Make scenarios on demand, aggregating the JSON outputs, and compiling a report for a human operator.
Controlled access to automation: Teams can keep business logic and integrations inside Make while safely exposing only selected on‑demand scenarios to AI tools via MCP.

Notes and Best Practices

Only scenarios configured with “On‑Demand” scheduling are discoverable — review your scenario settings before expecting them to appear.
Validate inputs and test scenarios manually in Make before exposing them to AI-driven invocations.
Prefer the cloud-hosted MCP server for production to avoid managing uptime, updates, and scaling.
Rotate API keys regularly and restrict scopes to the minimum required.

For development and troubleshooting, consult the GitHub repository and the cloud documentation linked above.

Make MCP Server: New Cloud-Based Version