Zapier counts tasks. Make counts operations. n8n counts workflow executions. Three platforms that do roughly the same job, priced in three different units, which makes comparing them feel like comparing dollars to euros to seashells. That confusion is not an accident, and it is why so many people overpay for automation they could get for a third of the cost.
I run both Make and n8n in my own stack, and after looking at all three side by side in a separate comparison, I wanted to give Make a proper review of its own. Because the short version is this: Make is the automation tool I’d hand to most small businesses that have outgrown simple two-step Zaps. It’s also the one with the steepest ramp-up, and you should know that before you commit.
A quick note on links: some links in this post are tracked, and we may earn a commission if you sign up through them. It costs you nothing extra and it doesn’t change what I say below.
Key Takeaways
- Make (formerly Integromat) is a visual automation platform built around a canvas where branching, loops, and error routes are all visible at a glance.
- Paid plans start at $9/month (Core, billed annually) with 10,000 operations per month. The free plan gives you 1,000 operations and 2 active scenarios.
- Per-operation pricing is much cheaper than Zapier’s per-task model once your workflows have more than a few steps.
- The learning curve is real. Non-technical users typically need 10 to 20 hours to get comfortable, according to independent reviews.
- There’s no self-hosting option. If you need data residency or full infrastructure control, n8n is the better fit.
- AI is now a real part of the product: a natural-language assistant called Maia, plus AI Agents that shipped in 2026.
What Make.com Actually Is
Make started life as Integromat, a European automation tool that Celonis picked up in 2022 and rebranded. That heritage matters. While Zapier grew up serving marketers who wanted Gmail-to-Sheets in two clicks, Make was built for people who eventually need loops, filters, and error branches without duct-taping three workflows together.
Every automation in Make is called a scenario, and scenarios live on a 2D canvas. You drag modules onto the board, connect them with paths, and the flow of data becomes something you can literally see. A branch that runs only when a customer’s order exceeds $200 is a visible fork in the road, not a hidden filter buried in step four of a linear list.
The vendor lists more than 3,000 integrations, which is well short of Zapier’s 9,000+ app catalog but covers the mainstream SaaS world: CRMs like HubSpot and Pipedrive, marketing tools like Mailchimp and ActiveCampaign, and most AI services. For anything without a native module, Make’s HTTP module talks to any REST API directly. In practice I’ve found the integration count matters less than people assume; what matters more is whether your five or six key tools are covered well, and for most small businesses they are.
Make Pricing in 2026: What You Actually Pay
Make’s pricing looks simple on the surface and gets complicated the moment you read the fine print. Here are the current plans, checked against Make’s pricing page and multiple 2026 pricing breakdowns:
| Plan | Price (annual billing) | Operations/month | Main limits |
|---|---|---|---|
| Free | $0 | 1,000 | 2 active scenarios, 15-minute polling |
| Core | $9/mo | 10,000 | Unlimited active scenarios |
| Pro | $16/mo | 10,000 | Custom variables, higher scenario limits |
| Team | $29/mo | 10,000 | Role-based access, team workspaces |
| Enterprise | Custom | Custom | Priority support, SOC 2 options |
Two things worth knowing before you pick a plan. First, these are annual-billing rates; pay month to month and each tier costs more. Second, Make added operation rollover in 2026, so unused operations from a quiet month carry into the next one on paid plans. That’s a genuinely useful change for seasonal businesses whose volume swings.
Also pay attention to the free plan’s polling interval. Triggers that check for new data run on slower 15-minute cycles there, while paid plans tighten that considerably. If your workflow routes leads to salespeople, a 15-minute delay on the free tier is a real problem, not a footnote.
The Operations Math (This Is Where Make Wins)
Here’s the part most comparisons gloss over, and it’s the single biggest reason to consider Make over Zapier: the pricing model rewards multi-step workflows.
Zapier bills per task, where a task is one action step. Make charges per operation, which is roughly one module execution. For a two-step automation, the difference barely matters. For anything with branching, loops, or a fan-out to several destinations, it compounds fast.
Take a common lead-routing flow: a form submission gets checked against filters, enriched with data from a lookup, written to the CRM, and posted to a Slack channel. Call it five to six steps per run. Send 500 leads a month through it and you’re burning roughly 3,000 tasks in Zapier, which blows past the 750-task entry tier on the Professional plan almost immediately. The identical flow in Make costs around 3,000 operations, which sits comfortably inside the Core plan’s 10,000.
One honest caveat: operations are only cheaper if your scenarios are built sensibly. An iterator that loops over a 50-row spreadsheet multiplies your operations by 50 in one run. I learned this the hard way watching the operation counter spike after adding a loop without a filter. Make shows you exactly which module ate the budget, which is more than Zapier’s task log does, but sloppy design is still expensive design.
Where Make Genuinely Shines
- The visual canvas. Branching, looping, and data aggregation render as a flowchart rather than a numbered list. When I come back to a scenario months later, I can see what it does in seconds.
- Per-module error handling. Each module gets its own error route, retry policy, and resume behavior. A failed payment webhook can route into a recovery path instead of silently dying. This is the most production-grade error handling I’ve seen at this price point, and it’s a real gap in Zapier’s design.
- Built-in state. Make’s Data Store is a simple key-value database for tracking what you’ve already processed, so you don’t need to bolt a spreadsheet onto your automation just to remember the last sync timestamp.
- The AI layer is real. Maia, Make’s AI assistant, turns a plain-English description into a starting scenario, and Make shipped AI Agents and MCP tool support in 2026. It’s the easiest on-ramp I’ve seen for teams that want AI in their workflows without running their own model infrastructure.
- Transparent cost visibility. Every run shows which modules consumed operations, so you can refactor the expensive branch instead of guessing.
Where Make Stumbles
- The learning curve. Independent reviews consistently put non-technical users at 10 to 20 hours before real comfort. That’s a genuine cost if nobody on your team is technical. Zapier gets you running in minutes; Make gets you running in an afternoon, at best.
- Operation surprises. Iterators, aggregators, and instant triggers can inflate the count on poorly designed scenarios. The billing terminology has also drifted between “operations” and “credits” over the years, which hasn’t helped anyone’s budgeting.
- No self-hosting. Make is cloud-only. There’s an EU region for GDPR-sensitive teams, but if your compliance requirements demand the data never leaves infrastructure you control, this is a dealbreaker and n8n is your tool.
- Support has a mixed reputation. User reviews on Trustpilot and community forums frequently mention cryptic error messages and slow support responses. Not universal, but common enough that you should plan to be self-sufficient.
One independent test lab, hackdvisor, scored Make 4.2 out of 5 overall in its 2026 review, with the automation engine itself at 4.8. That split tells the story pretty well: the engine is excellent, and the pricing complexity and learning curve drag the overall score down.
Make vs Zapier vs n8n: The Short Version
If you want the full head-to-head, I’ve got a dedicated Make vs Zapier vs n8n comparison on the site. Here’s the condensed view for anyone evaluating Make specifically:
| Make | Zapier | n8n | |
|---|---|---|---|
| Pricing basis | Operations | Tasks | Executions (cloud) or self-hosted |
| Entry paid price | ~$9/mo (Core, annual) | From $19.99/mo (Pro, annual) | €20/mo (~$24) Starter, annual |
| Free tier | 1,000 ops, 2 scenarios | 100 tasks/mo | Free if self-hosted |
| Integrations | 3,000+ | 9,000+ | A few hundred native, plus universal HTTP node |
| Visual builder | Canvas with branching and loops | Linear, branching feels bolted on | Canvas, more technical feel |
| Error handling | Per-module routes and retries | Basic notifications and retries | Flexible, custom error workflows |
| Self-hosting | No | No | Yes |
| Best for | Multi-step logic at an SMB price | Quick, simple automations | Technical teams and data control |
My rule of thumb: under about 2,000 actions a month and simple logic, Zapier’s free tier is friendly and fast to ship. Past that, Make’s math starts winning, and it keeps winning as volume grows. One Zapier-side note: its AI products (Agents, Chatbots) are priced as separate add-ons, so the sticker price of a “Professional” plan doesn’t tell the whole story if AI is part of your plan. n8n bills per execution regardless of complexity and hands you the code-level control Make won’t, but someone on your team needs to be comfortable with actual technical work.
How I Evaluated This, Honestly
I use both Make and n8n in my own operation, so the canvas, the operation counter, and the error-routing behavior are things I’ve lived with rather than read about. I have not run Zapier in production, so where Zapier appears here I’m leaning on its own documentation and pricing pages plus consistent patterns in user reviews, not personal war stories.
Beyond that, this review draws on Make’s current pricing pages, independent 2026 reviews from test labs and agencies, and a healthy amount of Trustpilot and community-thread reading. I’ve reviewed a lot of tools on this site over the past year, and automation is the category where vendors try hardest to make pricing impossible to compare. When a claim here depends on a vendor’s own numbers, I’ve flagged it as such. Pricing changes, so treat every figure as a snapshot from September 2026 and check Make’s pricing page before you budget.
Who Should Skip Make
If you’re completely non-technical and you only need simple connections, like “new form row goes to my spreadsheet,” you’ll pay a learning tax you don’t need to pay. Zapier’s free plan handles that use case with less friction. If data residency is a hard requirement, Make’s EU region may satisfy a typical GDPR review, but anyone whose legal team requires full infrastructure control should look at n8n’s self-hosted option instead. And if your automation volume is genuinely huge, running hundreds of thousands of executions monthly, self-hosted n8n costs almost nothing to run and Make’s operations bill will sting.
Frequently Asked Questions
What counts as an operation in Make?
Roughly one module execution. A scenario with six modules that runs once consumes about six operations. Iterators multiply this, since each looped item counts separately. Data Store reads and writes also consume credits, which surprises some people on the free plan.
Does Make have a free plan worth using?
Yes, within limits. You get 1,000 operations a month and 2 active scenarios, which is enough to prototype real workflows before paying. The slower 15-minute polling on triggers is the main catch for anything time-sensitive.
Is Make cheaper than Zapier?
For multi-step workflows, usually yes, sometimes dramatically so. The crossover point is somewhere around a few thousand monthly actions; below that, Zapier’s free tier may cover you entirely, and Make’s advantage hasn’t kicked in yet. Above it, Make’s per-operation model typically costs a fraction of the equivalent Zapier setup.
Can I self-host Make like n8n?
No. Make is cloud-only, with an EU region available. If self-hosting is a requirement, n8n is the platform that offers it.
The Verdict
Make is the automation tool I recommend first for small businesses whose workflows have outgrown two-step connections. The visual canvas makes complex logic readable, the error handling is genuinely better than anything else at this price, and the per-operation pricing means a 10,000-operation Core plan at $9 a month handles workloads that would cost several times more on Zapier. The tradeoffs are a real learning curve and a cloud-only setup.
Start on the free plan and build the workflow you actually need. Watch the operation counter on a few runs. If your monthly volume lands anywhere near 2,000 operations, Make’s Core plan will almost certainly cost less than what you’d pay Zapier for the same work, and you’ll be able to see every branch of the thing you built. That combination of price and visibility is why it’s earned a permanent spot in my own stack.