Make
Design, build, and automate anything, visually.
What is Make?
Make is a no-code/low-code automation and iPaaS platform that lets users visually design 'scenarios' connecting 3,000+ apps into automated multi-step workflows. Its node-based drag-and-drop canvas exposes deep control (routers, filters, iterators, and error handling) making it more visual and, at high volume, more affordable than Zapier, since it bills per module step rather than per task. Originally launched as Integromat in 2012 and rebranded to Make in 2022 under owner Celonis, it targets ops, marketing, and technical teams that want automation power without heavy engineering.
Best known for: A visual builder that's cheaper than Zapier at scale
Key features
- Visual, node-based scenario builder
- 3,000+ app integrations plus universal HTTP module
- Routers, filters, and conditional branching
- Iterators, aggregators, and data mapping
- Error handling with retries and detailed logs
- AI agents and native LLM modules
Who Make is best for
- Teams that need complex, branching multi-step workflows
- Teams running high automation volume that want lower per-run cost than Zapier
- Teams that prefer a visual builder but want deep control (filters, iterators, error handling)
Ideal team: Automation-heavy, moderately technical ops or marketing teams of 1–50 who want power and volume without engineering headcount.
Make pricing
Free
$0
- 1,000 credits/mo
- 3,000+ apps
- Routers & filters
Core
$12/mo
- Unlimited active scenarios
- 10,000 credits/mo
- Make API access
Pro
$21/mo
- Priority execution
- Custom variables
- Full-text log search
Costs to watch before you commit
- Billing is per module step (credits, formerly 'operations'), complex scenarios burn credits fast and overages force an upgrade.
- The powerful visual builder has a steeper learning curve than Zapier for beginners.
- Advertised prices require annual billing; monthly costs ~15% more and higher credit tiers scale the price up steeply.
Make pros and cons
Pros
- The visual scenario builder shows branching, filters, and error paths as an actual diagram rather than a list of steps
- Core at $12 for 10,000 credits is far more generous than Zapier's equivalent tier
- Routers, filters, iterators, and aggregators make genuinely complex logic possible without code
- 3,000+ app integrations, so coverage is rarely the constraint
- 4.7 from 680 reviews, and it appears on 22 competitor alternatives pages in our catalog
- A free plan with 1,000 credits a month that does not expire
Cons
- Every module action consumes a credit, so a well-built multi-step scenario costs more than a crude one
- The learning curve is real: the power that makes it worth choosing is what makes the first hour confusing
- The 15-minute minimum interval on free makes near-real-time work impossible without paying
- Advertised rates assume annual billing; monthly is around 15% higher
- Credit consumption is hard to forecast before building, and overages force an upgrade
- Error handling and debugging, while capable, take effort to learn properly
Make review: a closer look
What Make is
Make, formerly Integromat, is a visual automation platform that connects applications and moves data between them. Its distinguishing feature is the canvas: scenarios are laid out as a diagram you can see, with branches, filters, loops, and error handlers drawn as paths rather than hidden in a linear list. It sits between Zapier's simplicity and a developer tool's flexibility, and with 680 reviews at 4.7 it is one of the most established products in the category.
The canvas is the reason to choose it
Zapier models automation as a sequence: trigger, then action, then action. That is correct for most simple tasks and becomes a poor fit the moment logic branches. Make draws the whole scenario, so a workflow that routes high-value orders one way and everything else another, loops over line items, and handles a failed API call separately is visible as a shape you can reason about. For anyone who has tried to debug a long linear automation and lost track of what runs when, this is the difference. It is also why Make takes longer to learn: you are being handed a more capable tool, and the interface does not hide that.
Credits are consumed per action, which cuts against complexity
This is the cost model to understand, and it is the opposite of Latenode's. Every module action counts as one credit: adding a row, fetching a record, sending a message. A scenario with twelve modules that runs a hundred times a month consumes 1,200 credits, while a crude two-module version of the same job consumes 200. The practical effect is a quiet incentive to build simpler automations than you otherwise would, which is exactly backwards from what good design suggests. Core at $12 includes 10,000 credits, which covers a great deal for a small business, but forecast your usage by multiplying modules by expected runs rather than by counting scenarios, because that is the number that matters.
Where the free plan stops
Free gives 1,000 credits a month and access to 3,000+ apps, which is a genuine plan rather than a trial. The limit that pushes people to pay is usually not the credits but the 15-minute minimum interval between runs. Anything that needs to react promptly, an order notification, a lead alert, a support ticket routing rule, is unusable at that cadence. If your automations are batch work that can run every quarter hour, free may serve indefinitely. If anything needs to feel immediate, Core is the real entry point and the free plan is an evaluation tool.
How it compares
Against Zapier, Zapier is easier to learn, has more integrations, and costs considerably more for equivalent volume; Make is the better tool once logic branches. Against n8n, n8n is more technical and can be self-hosted for infrastructure cost alone. Against Latenode, that bills by compute time rather than per action, which favors dense multi-step workflows where Make's model does not. Against Power Automate, that makes sense inside a Microsoft-committed organization. Against Relay.app, which shut down in September 2026, Make is one of the main destinations for teams migrating off it. The honest summary: Make is the best value in visual automation for anyone whose workflows are more than a straight line.
Who should use Make?
A good fit
Make fits small and mid-sized businesses, agencies, and operations teams of roughly 1 to 50 whose automations involve real branching: conditional routing, loops over records, or different handling for different cases. It suits people willing to spend a first afternoon learning the canvas in exchange for a tool that will not run out of capability, and anyone finding Zapier's per-task pricing expensive at volume.
Look elsewhere if…
Teams wanting the simplest possible experience should use Zapier, where the first automation takes ten minutes and the ecosystem is larger. Technical teams should price n8n, which is cheaper self-hosted and more flexible. Businesses running dense multi-step workflows at volume should compare Latenode, since paying for compute time rather than per action suits that shape better. And anyone whose automations must react instantly should budget for Core rather than assuming the free plan will do.
The verdict
Make is the strongest value in visual automation, and the canvas is a genuine advantage rather than a presentational one: seeing branches and error paths as a diagram is what makes complex scenarios maintainable instead of mysterious. At $12 for 10,000 credits it undercuts Zapier substantially for equivalent work. Two things to plan for. Credits are consumed per module action, so estimate modules multiplied by runs rather than counting scenarios, and note the model mildly penalizes building things well. And the free plan's 15-minute minimum interval, not its credit allowance, is usually what forces the upgrade.
Compare Make head-to-head
See how Make stacks up against the alternatives, full BUILD · STACK · FLOW breakdowns of pricing, features, and automation recipes.
Make vs 
n8nPricing, features & automation recipesMake vs 
ZapierPricing, features & automation recipes