Make

com.makePublished by make.comOfficial publisherv2.0.0Updated Oct 29, 2026

Build, run and debug Make automation scenarios.

VerifiedStreamable HTTPWeb executableProductivity & WorkflowDeveloper Tools

Overview

AI-generated overview

Make's remote MCP server lets an AI assistant build, explain, run and debug Make automation scenarios and author TypeScript Functions v2.

What you can do
  • Explore an account: list organizations, teams and scenarios, explain what a scenario does, check connection health
  • Build and edit scenarios: discover apps and modules, set up connections, resolve account-dependent values, add flow control, error handling, subscenarios and AI agents
  • Operate scenarios: run, activate and deactivate, review and debug executions, investigate webhooks
  • Author and operate TypeScript Functions v2, including endpoint discovery and execution recovery
  • Read-only checks such as environment_get, function_list and function_endpoint_list to verify the connection and target team
When to use it
Useful when you work in Make and want an assistant to inspect an account, draft or modify scenarios, or troubleshoot failed executions without switching to the editor. Also relevant for teams authoring Functions v2, provided rollout access is in place.
Requirements
Remote HTTP endpoint at mcp.make.com, with platform-specific paths for Claude Code, Cursor and OpenAI Codex. A Make account and OAuth sign-in through Make's consent screen are required. Functions v2 needs the curated Functions tools and team rollout access; installing a skill does not enable them.
Before you install
OAuth grants a broad all-or-nothing access bundle, and tool availability or team access is checked separately from consent. Scenario tools can create, edit, activate and run automations, which may trigger real app actions. Never paste provider secrets into an agent conversation; use Make's credential-request flow so the owner supplies secrets in Make.

Installation

In SourceWeft

  1. Open Make in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/com.make%2Fmcp-server/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "make": {
      "type": "http",
      "url": "https://mcp.make.com/v2"
    }
  }
}

README

Make Skills for AI Coding Agents

Give your AI coding agent deep Make expertise — for building, explaining, running and debugging Make scenarios and authoring and operating Functions v2 through Make's MCP server, calling app Endpoints through the standalone Endpoints SDK or CLI, and securely requesting credentials for Endpoints and custom-app testing. Works with agents that read skill folders and can use the relevant interface — Claude Code, Codex, Cursor, GitHub Copilot, Windsurf, Cline, and others. For Make app development, use Make Apps Skill.

Skills

SkillWhat it does
make-scenario-referenceThe conventions every tool shares — scopes, the data/remark contract, structure vs configuration, the one-save write model, and what the surface refuses to author — for when a tool answers 403 or refuses something
make-scenario-exploreOrienting in an account — organizations, teams, listing scenarios, explaining what one does, connection health, account-wide checks
make-scenario-buildingCreating and editing scenarios — app and module discovery, connections, resolving account-dependent values, flow control, error handling, subscenarios, AI agents; with references and complete examples
make-scenario-operationsRunning, activating and deactivating, reviewing and debugging executions, investigating a webhook
make-endpointsDirect app actions through @makehq/endpoints-sdk or its CLI — discovery, managed connections, typed calls, complete retrieval, and approval-bound writes with readback. Endpoints are in closed beta.
make-functions-v2Authoring, testing, publishing and operating TypeScript Functions through the existing Make MCP connection, including Endpoint discovery and execution recovery. Requires Functions v2 rollout access.
make-credential-requestsCredential provisioning for agents using Endpoints or testing custom apps — the owner receives an authorization link and supplies secrets in Make; the agent resumes with managed connection/key IDs, not raw credentials. No scenario required.

Creating a connection in the scenario editor remains the standard manual path. Credential Requests are the recommended secure handoff for agents; they complement that editor workflow rather than replace it.

Prerequisites

  • A Make account
  • For scenario skills and make-functions-v2: access to the Make MCP server. Functions v2 also requires the curated Functions tools and team rollout access; installing the skill does not enable either.
  • For make-endpoints: an approved Node.js/terminal environment, the Endpoints package, and organization access to the Endpoints beta. See setup and interfaces. Installing this skill does not install the SDK or enable the beta.
  • For make-credential-requests: access to a chosen, authorized credential-request interface, with the required Make permissions and organization/team access. Verify that interface's current contract before making a request; installing a skill or plugin does not grant access. SDK/REST requests follow their own permission contracts, not the scenario MCP server's all-or-nothing OAuth bundle.

Installation

Install the skills and configure the interface they use. Scenario skills and make-functions-v2 use the same MCP server; make-endpoints uses @makehq/endpoints-sdk, which includes both the SDK and make-endpoints-cli. make-credential-requests uses the chosen authorized request interface to provision credentials, not execute app actions. Neither Endpoints execution nor credential provisioning requires building a scenario. Endpoints-only use does not require the scenario MCP server. The plugins below register that server for both scenario and Functions v2 skills; the standalone skill download can be used independently.

Option A: Plugin (recommended)

Claude Code

bash
/plugin marketplace add integromat/make-skills/plugin install make-skills@make-marketplace

Cursor — Team Marketplace: import integromat/make-skills and install make. The plugin registers the MCP server (/cursor).

Codex

bash
codex plugin marketplace add integromat/make-skills

Then open the plugin directory, select the Make marketplace, and install make. If the MCP server is not registered automatically, add it manually:

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

Option B: Download the skills

Upload the zips to your agent (Claude Cowork, Claude Chat, and similar) or unzip them into its skills directory:

SkillDownload
Bundle of all the skillsDownload
Scenario ReferenceDownload
Scenario ExploreDownload
Scenario BuildingDownload
Scenario OperationsDownload
Make EndpointsDownload
Functions v2Download
Make Credential RequestsDownload

Skills directories, for agents that read skills from disk:

AgentSkills directory
Codex (project).agents/skills/
Codex (global)~/.agents/skills/
Claude Code.claude/skills/
Cursor.cursor/skills/
Windsurf.windsurf/skills/
Cline.cline/skills/
Generic.agents/skills/

ChatGPT does not use a local skills directory. Install the Make plugin or use the skill-upload flow supported by the selected ChatGPT experience; configure and authenticate its Make connection separately. Unzip each downloaded skill so its folder directly contains SKILL.md, references/ and examples/.

Add the MCP server manually for scenario and Functions v2 skills

Skip this if a plugin registered it. Each platform has its own endpoint, over HTTP:

PlatformMCP URL
Claude Codehttps://mcp.make.com/claude
Cursorhttps://mcp.make.com/cursor
OpenAI Codexhttps://mcp.make.com/openai
bash
claude mcp add --transport http make https://mcp.make.com/claudeclaude mcp list

For any other agent, add the matching URL to its JSON MCP config.

On first use, authenticate through Make's OAuth consent screen. Follow the tool's authorization challenge to grant its required access area. Functions v2 uses Build & Run; tool availability and team rollout access are separate from OAuth consent.

Verify the skill and connection

After installation and sign-in, refresh the client's available skills and tools (restart the client if needed). Use this read-only check before creating anything:

Use the make-functions-v2 skill. Check the Make connection, call environment_get, and show the available organizations and teams so I can select the target. Confirm that function_list, function_endpoint_list and function_endpoint_types are available. Do not create or run a Function yet.

The skill being discoverable, MCP being authenticated, the required tools being present, and access to the selected team are separate checks. For scenario work, use make-scenario-explore and check scenario_list instead. Reuse the configured Make connection; adding a duplicate does not grant missing access.

Functions that call Endpoints also need organization access to Endpoint execution and available generated Endpoint types. Discover the selected team's Endpoints, then retrieve their types before authoring calls. If no compatible Connection exists, create one in Make or use an available, authorized Credential Requests workflow. Complete authorization in Make, then repeat Endpoint discovery; never paste provider secrets into an agent conversation. See Functions access and discovery.

Troubleshooting

IssueSolution
MCP server not connectingConfirm the server is configured, complete OAuth sign-in, then refresh tools; check network connectivity if connection still fails
MCP permission denied / 403Follow the challenge for the required access area and confirm access to the target team/resource
An MCP tool refuses a writeRead the refusal and the current tool contract; use the Make editor for capabilities the tool explicitly does not support
Endpoints SDK/CLI access failureCheck the selected key/zone, Make scopes, team access and provider connection separately; the MCP full-scope-bundle rule does not apply
Functions tools missingConfirm the client has refreshed its catalog and the account/team has Functions rollout access. Installing the skill does not enable tools.
Functions Endpoint availability unavailableAsk the administrator to check organization Endpoint execution access and upstream availability. This is separate from Functions rollout and OAuth consent; do not assume the catalog is empty.
Endpoint types unavailableDiscovery may succeed while generated types are unavailable. Report the returned status and stop authoring the affected dependency.
Skill not foundCheck the installation scope and folder layout, then refresh/restart the client. Updating the repository does not update a previously copied skill.
Endpoints execution unavailableConfirm organization beta/runtime access; local catalog discovery and package installation do not enable execution

Contributing

Open pull requests against main — that's the trunk. Use squash merges and Conventional Commit PR titles (feat:, fix:, docs:, …), since release-please relies on them. A separate latest branch is fast-forwarded to each released tag. The Claude Code marketplace entry uses a local ./plugins/make-skills-claude source, so installs track the branch the marketplace is added from. Codex and npx skills add still resolve main HEAD directly. For Cursor Team Marketplace, import this repo and track branch main (branch is not set in .cursor-plugin/marketplace.json).

License

MIT

Source: README.md at commit 9c42980

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

2
  1. v2.0.0LatestOct 29, 2026
  2. v1.1.0Sep 16, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

Other Make integrations

UGC Fans

fans.ugcOfficial publisher

Remote UGC Fans server that lets an assistant generate ads, images and video, capture websites into launch films, and finish footage, with credit quotes first.

Streamable HTTPWeb executable
Browser Automation30 toolsNov 4, 2026

MakeMyClip Editor

Published by GitHub account MakeMyClip

Local, open-source video editor an assistant drives: cut silence and retakes, edit by transcript, add captions, and export mp4 or Final Cut/Resolve/Premiere…

STDIODesktop only
Productivity & Workflow8 toolsNov 8, 2026

MakeBox for Etsy

Published by GitHub account russol07

Remote MakeBox connector for Etsy: drafts SEO-optimized listings and, with OAuth, runs live Etsy shop operations for an authorized seller.

Streamable HTTPWeb executableAuth
Developer ToolsCredential requiredNov 6, 2026

Make

Published by GitHub account integromat

Make's remote MCP server lets an AI assistant build, explain, run and debug Make automation scenarios and author Functions v2.

Streamable HTTPWeb executableAuth
Productivity & WorkflowCredential requiredOct 24, 2026

WebMCP — Make Any Website Agent-Ready

Published by GitHub account up2itnow0822

TypeScript SDK for exposing website tools to browser agents via the experimental W3C WebMCP API, with authorization, limits and a wallet demo.

STDIODesktop only
Browser AutomationNot validated yetOct 27, 2026