Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Make supports two opposite MCP integrations. Use Make MCP Server when an external AI client needs to run your Make scenarios. Use Make MCP Client when a Make scenario or agent needs to call tools hosted by another MCP server. Choose the direction first; the setup, permissions, and connection details differ.
Choose which system should call the tools
Model Context Protocol (MCP) provides a way for compatible clients and servers to exchange tool information and requests. In Make, “server” and “client” name two different connection directions; they are not interchangeable settings.
| Your goal | Make integration | Connection flow |
|---|---|---|
| Let an external MCP-compatible AI client run a Make workflow | Make MCP Server | AI client → Make-hosted MCP server → configured Make scenario |
| Let a Make workflow or agent use a tool hosted elsewhere | Make MCP Client | Make scenario or agent → external MCP server → selected tool |
The rest of this guide covers both paths. Start with the server route if you want an AI client to trigger work you have already built in Make; use the client route if the missing capability is on another MCP server.
Recommended Free Tools
Expose Make scenarios through Make MCP Server
Make MCP Server presents eligible Make scenarios as tools an MCP-compatible client can discover and call. Make also documents account-management tools that can be made available with broader permissions. Configure the scenario and decide what access to grant before connecting the client.
#1 Best Overall
1. Prepare a scenario for tool calls
- Build the workflow in Make and decide what information a caller must provide and what result it should receive.
- Define the scenario’s inputs and outputs deliberately. Inputs are the values the client supplies; outputs are how the client can interpret the result. Keep the exchanged data purposeful instead of exposing incidental workflow details.
- Set the scenario to active and configure on-demand scheduling. Make specifies both conditions for scenarios used as MCP tools. A scenario that is not callable in this way may not appear as an available tool.
Make’s Help Center and its MCP Server setup material describe the scenario requirements. Use the current labels and controls in your Make account when configuring the scenario; interface wording can change.
2. Select an authentication route
Make’s Developer Hub documents OAuth and MCP-token connections to its cloud-hosted MCP server, which uses stateless Streamable HTTP. The documented OAuth connection URL is https://mcp.make.com. For an MCP-token connection, the URL is zone-specific: use the URL Make provides for your account’s zone rather than guessing or substituting a generic host. Depending on the client and connection method, the token can be included in the URL or supplied as a Bearer authorization header.
Use the connection instructions for your particular MCP client. Do not paste a token into a public configuration, shared log, or source repository. Treat it as a credential: anyone who obtains it may be able to use the permissions associated with it.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 113. Grant only the scopes the client needs
Make separates scenario-run permissions from management permissions. Scenario-run tools let a client view and run activated on-demand scenarios. Management scopes can expose account objects such as scenarios, teams, connections, webhooks, and data stores. The Help Center says scenario-run scopes are available across plans, while management scopes require a paid plan.
Choose the narrowest suitable scope set and review it before authorizing. If you need access restricted to one Make organization, Make documents OAuth as the route that allows a user to impose that organization-level restriction. Do not assume an MCP token offers the same organization restriction.
4. Connect the MCP client and check its tools
Add Make’s remote MCP server using the URL and authentication method required by your client. Complete the OAuth flow or configure the MCP token as directed by the client, then inspect the tools it discovers. Make’s Developer Hub describes several ways to check tool availability: the client’s connector settings, an MCP command, MCP Inspector, or a tools/list request.
Rank #3
Confirm that the intended scenario is listed and that its inputs and outputs make sense before relying on it in an agent workflow. If management scopes were granted, inspect those available tools too; their presence means the connection reaches beyond simply running scenarios.
Call an external MCP server from Make
Choose Make MCP Client when your automation needs a tool hosted outside Make—for example, a capability exposed by a partner or internal MCP server. Make’s product explainer gives GitHub, Webflow, and PayPal as examples of remote servers; those examples do not guarantee that a particular server, tool, or account is available to you. The external service controls its own endpoint, authentication, and tool availability.
Set up the client module in a scenario
- Open or create the Make scenario that should use the external capability.
- Add Make’s MCP Client module to the scenario.
- Enter the external MCP server URL and configure the authentication it requires. Make describes OAuth and token-based authentication support; the correct choice and credentials depend on that server.
- Select one of the tools exposed by the server. Map the required inputs using the fields and help text displayed for the selected tool.
- Run the scenario and inspect the returned response. Use that result in later modules only after checking its structure and handling cases where a tool returns an unexpected or unsuccessful result.
Make describes visual input mapping and schema validation for the client module. That helps map values to a tool’s declared inputs, but it does not remove the need to verify the remote server’s requirements or the meaning of its response.
Timeouts, plan access, and scenario costs
Make’s published Developer Hub timeout limits vary by tool type and connection method. These are operational limits, not a promise that a scenario will finish within that time. Check the current Developer Hub documentation before designing around a limit because published values may change.
| Tool type | OAuth timeout | MCP-token URL timeout |
|---|---|---|
| Scenario-run tools | 25 seconds | 40 seconds |
| Management tools | 30 seconds | 60 seconds |
Make’s official product FAQ says MCP Server and MCP Client are included with Make plans, while credits are consumed by scenarios executed in Make. Inclusion of the MCP integration does not mean scenario executions have no credit cost. Also distinguish that general inclusion from permission eligibility: management scopes require a paid plan, whereas scenario-run scopes are available across plans.
For a slow operation, avoid designing a client call that must wait for more work than its applicable timeout allows. Consider whether the Make workflow can return promptly and whether a later result-retrieval pattern is supported by the current Developer Hub documentation. Verify the connection method and tool type before diagnosing a timeout.
Best Value
- Book - powershell for sysadmins: workflow automation made easy
- Language: english
- Binding: paperback
Troubleshooting common setup problems
- The scenario is missing from the client’s tool list. Check that it is active and set to on-demand scheduling, and confirm that the connection has the scenario-run scope. Then refresh or inspect the client’s discovered tools.
- The client cannot provide the needed values or understand the result. Revisit the scenario’s input and output definitions. These define the data exchanged with the caller; they should match the values the client can supply and the result it needs to use.
- The client can see more Make resources than intended. Review the authorized scopes and remove unnecessary management access. If you require access restricted to a particular organization, use the OAuth option documented for that restriction.
- A call ends before the workflow completes. Identify whether it is a scenario-run or management tool and whether it connects through OAuth or an MCP-token URL. Compare the operation with the corresponding published timeout, then redesign long-running work to return promptly or use a supported later-retrieval approach.
- The MCP Client module cannot connect or a tool is unavailable. Check the external server URL, the selected tool’s availability, and the server’s authentication requirements. The remote server—not Make—determines those endpoint and credential details.
- Mapped input is rejected or the response is unusable. Compare the mapped values with the tool’s displayed schema and help text. Validate the response from a test run before downstream modules depend on its fields.
For a separate website-screenshot task
ScreenshotNeo is a website screenshot API, not a way to connect Make to an MCP server. If your workflow also needs to capture web pages, it can handle that separate task without you setting up a browser for the capture. Its API accepts a URL in a GET request and can return an image or PDF. The following cURL example requests a WebP screenshot of Stripe:
ScreenshotNeo API documentation
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo removes cookie and consent banners, newsletter popups, and chat widgets before capture; those steps can each be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed. It also offers an MCP server with take_screenshot, get_page_info, and capture_pdf tools for compatible AI clients. The free plan includes 1,000 shots a month without a card; paid plans start at $5 for 3,000 shots.
Sign up for ScreenshotNeo’s free plan: 1,000 screenshots a month, no card required.
Free tools Windows power users keep installed
One-click scans. No signup required.
Frequently Asked Questions
Does Make MCP Server work with every AI client?
It is intended for MCP-compatible clients. Follow the remote-server setup and authentication instructions for the specific client you use; compatibility and configuration details are client-dependent.
Can I use Make MCP Server without OAuth?
Make documents an MCP-token connection as well as OAuth. The token URL is zone-specific, so obtain the appropriate URL from Make’s documentation or account setup rather than assuming one.
Can one Make setup use both MCP directions?
The two routes serve different jobs: one exposes Make scenarios to outside clients, and the other lets Make call outside tools. Use the route needed for each connection; the documentation here does not establish a single combined setup procedure.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
