Make

Section 2 — Is this for you?

Make is the automation tool people pick when they want to see their workflow laid out like a map, not a list. If Zapier looks like a checklist, Make looks like a flowchart — and that difference matters more than you'd think once your automation grows past a handful of steps.

It also happens to be one of the cheapest ways to run a lot of steps. Make's billing is built around "credits" (which replaced "operations" in August 2025, at a 1:1 rate), and credits are roughly 30x cheaper per step than Zapier tasks. So if your automation runs many small steps, Make's math is very friendly.

Make is the right pick when:

• You want a visual builder where you can see branches, loops, and data flowing between modules
• You need lots of small steps per run and don't want Zapier's per-task bill
• You want your data hosted in the EU (Make lets you pick US or EU at signup)
• You're already in the Celonis ecosystem or plan to pair automation with process mining
• You like the idea of a powerful free tier (1,000 credits/month) to learn on

Make might work, but watch for:

• You need HIPAA and a signed BAA — Make does not sign BAAs, full stop
• Your scenarios need to run longer than 40 minutes each (that's the hard ceiling)
• You want a big ecosystem of pre-built templates and onboarding (Zapier's is deeper)
• You need strict dev/staging/prod environments (Make doesn't have true environments)

Look elsewhere when:

• You're building clinical or healthcare workflows touching PHI — look at Power Automate under a Microsoft BAA, or Workato
• You want to self-host everything — n8n is the clear choice
• You need heavy custom code in every step — Pipedream has much more code freedom

Section 3 — The real story

Make started life as Integromat, a Czech company that built a scrappy, visual-first alternative to Zapier. In 2020, Celonis (the big process-mining company) acquired it. By 2022 it had rebranded to Make.

That Celonis backing matters. It's why Make can keep credit prices low — it's not a standalone startup trying to hit a revenue target, it's part of a larger company that makes its real money selling process intelligence to the Fortune 500. Make is the automation layer underneath.

What the canvas actually gets you

Open a scenario for the first time and you'll see why people fall for Make. Modules are circles on a canvas. You connect them with lines. When a scenario runs, you can watch data flow module-to-module, see exactly what each one returned, and re-run from any step.

That visual clarity becomes essential once your workflow branches. A Router splits flow into two or more paths. An Iterator loops over an array. An Aggregator collects results back together. You can see the whole shape at a glance — no scrolling through a linear list trying to keep track of where you are.

The cost model people actually love

A credit = one module run. Triggers count. Aggregators count. Filters that pass count (filters that block don't).

So a scenario with 10 modules that runs 100 times a day uses 1,000 credits a day — about 30,000 a month. The Core plan at $9-15/month includes 10,000 credits, and you can scale up from there. Compare that to Zapier, where the same 10-step workflow running 100 times a day would eat 1,000 tasks a day, and you''d need a Team plan ($70+) just to fit.

Where Make still loses

Make''s app catalog is smaller than Zapier''s — somewhere around 2,500 apps vs Zapier''s 7,000+. For obscure SaaS tools, you''ll sometimes find that Make doesn''t have a native module and you need to fall back to the HTTP module (which works but means writing the API call yourself).

The templates library is also thinner. Zapier throws pre-built automations at you during onboarding; Make leans more on its community and YouTube to carry people through their first scenarios.

The honest summary

If you''re comfortable looking at a canvas and thinking about data flow, Make is probably the best pure automation value on the market. If you want something that holds your hand and hides the complexity, Zapier is still the smoother ride.

Section 4 — How it actually works

The facts at a glance

Make runs entirely in the cloud (no self-host option except for enterprise Private Cloud). You pick a data region — US or EU — when you create your organization, and that choice is permanent for that org. If you need to switch later, you create a new org and migrate scenarios over.

Hosting and data residency

Two zones are available: US (us1.make.com) and EU (eu1.make.com). Most other cloud automation platforms are US-only, so the EU option is a real advantage if your compliance team cares about where data sits at rest.

Make does not publish latency numbers between zones, but most teams pick whichever is closer to the apps they''re integrating with to minimize round-trip time.

How credit billing works

Every module that runs costs 1 credit. That includes:

• Triggers (both instant webhooks and scheduled polling)
• Actions (API calls, database writes, everything else)
• Filters that pass (filters that block the flow don''t charge)
• Routers and Aggregators (yes, they count)
• Iterators (each item in the loop = 1 credit)

AI modules that use Make''s built-in AI provider are billed differently — they charge extra credits based on the number of tokens consumed. If you bring your own OpenAI or Anthropic key, those calls are just 1 credit per module (you pay the AI provider directly for tokens).

Extra credits (beyond your plan allowance) cost 25% more than your base plan rate — Make bumped this in November 2025. Auto-purchase and manual purchase both carry the same premium.

The builder

Make''s canvas is the main event. Drag modules, connect them, double-click to configure. Data from one module shows up as chips you can drag into the next module''s fields.

Right-click any module to get a bubble showing its last execution — input, output, timing, errors. Re-run the whole scenario or just that one module. This kind of debugging feels much more like working with a real tool than Zapier''s linear test runs.

Triggers: instant vs scheduled

Instant triggers fire the moment a webhook arrives. They run continuously and most apps that support Make have them. Default rate limit: 30 webhook events per second before Make starts queuing.

Scheduled triggers poll on a fixed schedule. The floor is 1 minute on Pro and above, 15 minutes on Free and Core. If you need sub-minute reactions, use an instant trigger.

Branching with Routers

Routers are the best branching model in no-code automation. Split flow into as many branches as you want, run them in any order, and — critically — merge the results back together with an Aggregator. Nest Routers inside other Routers without hitting any hard limit.

The only practical limit is the 40-minute execution ceiling. If a scenario has to do too much inside one run, it gets killed with a MAXIMUM EXECUTION TIMEOUT error.

Section 5 — Where it shines

The canvas

We keep coming back to this because it''s genuinely Make''s killer feature. Debugging a 30-module scenario feels like looking at a map. Debugging a 30-step Zap feels like reading a boring email.

Credit math for multi-step scenarios

If your automation is small (3-5 steps) and runs rarely, any tool will do. But if you have workflows with 15-20 modules running thousands of times a month, Make''s per-credit pricing is hard to beat. The same work on Zapier can cost 10-20x more.

Routers, Iterators, Aggregators

These three primitives make Make feel like a real programming tool without making you write code. Need to fan out to three APIs in parallel and collect results? Three routes + aggregator. Need to process every line of a CSV? Iterator + aggregator. No awkward workarounds.

Built-in tools

Make ships with a big set of utility modules that cover things you''d normally write code for: JSON parse/stringify, text parsing with regex, date math, math operations, CSV handling, sleep/delay, data storage. You rarely need to leave the canvas.

EU data residency

Most US-based automation platforms don''t offer an EU option. Make does, and it''s chosen at organization creation. If your GDPR team cares about where data is processed, this is a clean answer.

Free tier that actually works

1,000 credits per month is enough to learn Make properly and run genuinely useful personal automations. The main limits on Free: 15-minute polling floor, 10-minute execution limit, and you can''t publish some advanced modules. But it''s not a crippled demo — it''s a real free tier.

MCP server for AI agents

Make''s MCP server turns your scenarios into tools that any MCP-aware AI client (Claude, Cursor, others) can call. You generate a Make MCP Token, paste the URL into the client, and every published scenario becomes a callable tool. No local scaffolding, no custom server to maintain.

Section 6 — What breaks most often

The 40-minute execution ceiling

Every scenario has a hard 40-minute runtime limit. Hit it and the run is killed with a MAXIMUM EXECUTION TIMEOUT error — nothing is resumable. On the Free plan the limit drops to 10 minutes.

This burns people running big syncs (thousands of Salesforce records, for instance). The workaround is to split the work: use a scheduled scenario that processes batches of records and stores a cursor in a Data Store, so the next run picks up where the last one stopped.

Credits get confusing with AI modules

Non-AI modules are simple: 1 credit each. But AI modules that use Make''s built-in provider charge extra credits based on tokens consumed, and the cost per call can vary a lot depending on which model you pick and how much text you send.

Teams routinely blow through their credit budget on AI-heavy scenarios because they priced the workflow assuming 1 credit per AI call. Watch the credit usage panel closely the first week.

No true staging environment

Make doesn''t have environments. If you want to test changes without affecting production, the common pattern is either:

• Clone the scenario, edit the clone, test, then swap the names
• Use a separate organization for staging (which means re-creating connections)

Neither feels great for large teams with change-management processes.

HIPAA is a hard no

Make does not sign Business Associate Agreements. Full stop. If your workflow touches Protected Health Information, you cannot use Make — regardless of what other security controls are in place. This is a common reason healthcare teams rule Make out during procurement.

Regional lock-in

When you create an organization, you pick US or EU — and that choice is permanent. You can''t migrate an org between zones. If your compliance requirements change, you have to create a new org and manually rebuild your scenarios.

The app catalog has gaps

About 2,500 apps is a lot, but it''s noticeably smaller than Zapier''s 7,000+. For long-tail SaaS tools, you''ll sometimes find there''s no native module and you need to use the HTTP module to call the API directly. This works but means you''re on the hook for auth, pagination, and error handling.

Learning curve is real

The canvas is beautiful, but it takes longer to learn than Zapier''s linear builder. Most teams need a solid week before their non-technical members feel comfortable building scenarios without help.

Section 8 — Getting started reality

The signup flow

Head to make.com, pick the US or EU zone, and pick a plan (Free gets you going without a credit card). You''ll land in your first organization with an empty dashboard.

Your first scenario

Click "Create a new scenario." You''ll get a blank canvas with a big plus-button in the middle. Click it, pick a trigger module, configure it, then click the half-moon on the right side of the module to add the next one.

Make walks you through connecting each app the first time you use it. Connections are saved to your organization and reused across scenarios.

Most people''s first scenario is something like: Gmail trigger → Google Sheets action. Build it, turn it on, watch it run the first time an email comes in. The satisfaction of seeing data flow through the canvas in real time is Make''s honest on-ramp.

Where people get stuck

• Triggers don''t fire. Usually because you didn''t save the scenario or didn''t turn it on (there''s a switch in the bottom-left corner).
• Array shape is confusing. Some modules return a single item; some return arrays. If the next module expects one but you gave it many, you need an Iterator.
• Aggregators are weirder than they look. An Aggregator collects results from an Iterator back into an array. It has to sit *after* the loop, not inside it.
• Credit math gets away from you. Scenarios with AI modules or large iterators can burn through credits much faster than expected. Check the usage panel early and often.

Section 9 — Migration translations

From Zapier

• Zap → Scenario. Same idea, but the canvas is 2D instead of linear. Your Zap''s linear sequence becomes a straight line on Make''s canvas — and then you can start adding Routers and Iterators to simplify it.
• Task → Credit. Make counts every module run, including triggers and filters that pass. You''ll usually use more credits than you used tasks, but Make''s credits are about 30x cheaper per unit, so the bill still shrinks.
• Paths → Router + Aggregator. Make''s Router is Zapier''s Paths, but stronger. You can merge branches back together with an Aggregator — Paths can''t do this.
• Looping by Zapier → Iterator + Aggregator. Make''s Iterator is a real loop. No 500-iteration ceiling, no "one loop per Zap" rule.
• Sub-Zap → Scenario call. Make doesn''t have a true sub-scenario concept. Common pattern: call one scenario from another via webhook.

From n8n

• Workflow → Scenario. The visual builders are very similar. Both support branching, merging, and iteration.
• Execution → Credit. n8n bills once per workflow run. Make bills once per module. A 20-module scenario is 20 credits, not 1.
• Self-hosted → Cloud-only (or Private Cloud on Enterprise). If self-hosting is a hard requirement, Make is not the right destination.
• Code node → Tools modules + parsers. Make doesn''t let you write JavaScript in a step the way n8n does. Use Tools modules, JSON/Text parsers, and custom apps to cover most cases. For anything more involved, webhooks into a separate compute layer.

From Power Automate

• Flow → Scenario. Trigger + actions — same concept, different canvas.
• Premium connector → App integration. Make doesn''t gate apps behind premium tiers. Every app in the catalog works on every plan.
• Environment → (not available). Make has no dev/staging/prod split built in. Teams handle it with separate organizations or scenario clones.
• Dataverse → Data Store. Make''s Data Store is a simple key-value store. Much less capable than Dataverse but covers most automation state needs.

From Pipedream

• Workflow → Scenario. Both are visual node-based workflows.
• Credit (compute time) → Credit (module count). Pipedream charges for compute seconds, Make for module runs. A slow scenario and a fast scenario with the same module count cost the same in Make.
• Custom code → Tools modules + custom apps. Make''s code story is narrower than Pipedream''s. For heavy code steps, many teams call out to a Cloudflare Worker or Pipedream workflow from Make via HTTP.

Section 10 — AI & MCP readiness

Make''s AI provider

Make ships with a built-in AI provider that works without connecting your own OpenAI or Anthropic account. It charges credits based on tokens consumed — convenient, but the cost math is harder to predict than plain module billing.

Bring-your-own AI

Every paid plan (as of November 2025) supports custom AI provider connections. You can wire up your own OpenAI, Anthropic, Google, or Azure OpenAI account, and Make will use your API keys for the actual calls. In this mode, AI modules cost just 1 credit per run — you pay the provider directly for the token cost.

AI Agents

Make has been rolling out AI Agents that can orchestrate scenarios and make decisions. They''re newer than the MCP server and still maturing — treat them as beta rather than a production story today.

MCP server

This is the standout feature. Make''s MCP server is cloud-hosted, which means you don''t install or maintain anything. You generate a Make MCP Token, paste the URL into Claude, Cursor, or any other MCP client, and every published scenario becomes a callable tool. The AI discovers them at runtime, knows their inputs and outputs, and can call them directly.

Compared to other platforms'' MCP stories (which often require local setup or are still in beta), Make''s implementation is more production-ready.

The summary

If you want AI agents that can actually take action in your stack — not just chat — Make''s MCP server is one of the cleanest options available in 2026. You get the scenario canvas for building complex actions, and an AI can call those actions as tools.

Section 11 — Compliance at a glance

The facts

• SOC 2 Type II: Yes, audited annually
• SOC 3: Yes
• ISO 27001: Yes, certified
• GDPR: Yes, with EU data zone option
• HIPAA / BAA: No — Make does not sign Business Associate Agreements
• Data residency zones: US and EU (choose at organization creation; permanent)
• SSO: SAML 2.0 and OIDC, on the Enterprise plan
• Trains AI on your data: No
• Private Cloud (dedicated instance): Available on Enterprise

The fine print

Make''s compliance posture is strong for mainstream SaaS use — SOC 2, ISO 27001, GDPR with EU residency. For most commercial use cases this is more than enough.

The hard wall is healthcare. Make has been clear (and consistent for years) that it will not sign BAAs. If you have any scenario that could touch PHI — even indirectly, even in a test environment — Make is not the right tool. Look at Power Automate under Microsoft''s BAA, or healthcare-specific automation platforms like Workato or Redox.

The second thing to watch: the US/EU zone choice is permanent per organization. If you think you might need EU data residency in the future, create your first org in the EU zone now. Migrating later means manually rebuilding scenarios in a new org.