Make

Make (formerly Integromat) is the automation platform for people who outgrew simple connections. Where Zapier is a linear list of steps, Make gives you a visual canvas where scenarios branch, loop, merge and transform data — closer to how a developer would draw the logic, without writing code.

Its reputation is built on two things: price and power. Per operation, Make is typically cheaper than Zapier at volume, and its visual builder handles data transformation — filtering, aggregating, iterating, error routing — that Zapier makes awkward. For automations that process records rather than just trigger notifications, Make is the better tool.

The billing unit is credits. Most module actions consume one credit; AI steps through Make's own AI provider bill by tokens on top; and — the gotcha everyone learns eventually — polling triggers spend a credit on every check, even when they find nothing. A scenario that polls every minute can burn through credits while doing literally nothing.

How Make works

1. Build a scenario on the visual canvas — drag modules for triggers and actions.
2. Route data between them with wires; add routers, iterators, aggregators and error handlers.
3. Schedule or webhook the trigger; Make runs the scenario and bills credits per operation.
4. Monitor execution logs; buy extra credits or upgrade when you hit limits.

Key capabilities

Visual scenario builder — branch, loop, merge and transform data on a canvas.

Data transformation — built-in tools for filtering, mapping, aggregating and restructuring records.

Error handling — dedicated handlers, rollbacks and resume paths per scenario.

Scheduling and webhooks — run scenarios on intervals or react to instant events.

AI integration — Make AI Provider, AI agents and connections to OpenAI, Anthropic, Gemini.

HTTP and custom API modules — call any API, not just the catalogue.

Team features — shared scenarios, templates and roles on Teams plans.

What a scenario actually looks like

A realistic Make scenario shows why people switch: pull new rows from a Google Sheet → filter out test entries → look up each contact in your CRM via HTTP → score and tag them → write results back → alert your team on Slack only for high-value leads. Every arrow on the canvas is a decision point Zapier would make painful — branching on conditions, iterating over arrays, aggregating before writing.

That visibility is the real product. When a scenario fails at 2am, the execution log shows exactly which module broke and what data it saw — debugging an automation shouldn't require guessing, and Make treats it as a first-class feature rather than an afterthought.

Who it's really for

Make fits operators who think in flows: the person who needs "if this, then check that, and only if it matches do this other thing" — real conditional logic, not just step A to step B. It's the tool for automations that earn their complexity.

It fits less well for the person who just wants "when X happens, do Y" with zero thought — Zapier's linear model is faster for that. And for very high-frequency simple automations, Zapier's per-task pricing can actually be cheaper than Make's credit burn on polling triggers.

Make plans and pricing explained

Free — $0. 1,000 credits/month, up to 2 active scenarios, 15-minute minimum schedule, 5-minute max run time. Enough to learn and run small automations.

Core — from $12/month billed annually ($16 monthly) at 10,000 credits. Unlimited active scenarios, schedules down to 1 minute, 40-minute runs, API access. The plan for individuals running real automations.

Pro — from $21/month annually ($28 monthly) at the same 10,000 credits. Adds priority execution, custom variables, full-text log search and larger file handling. You pay more for features, not more credits.

Teams — from $38/month annually ($51 monthly) at 10,000 credits. Teams and roles, shared templates, bigger files. For groups collaborating on automation.

Enterprise — custom. Credit overage protection, custom functions, enterprise apps, 24/7 support.

Credit math — credits scale with your volume via a slider; a single scenario can consume anywhere from 2 credits per run to thousands if it processes large datasets. AI steps bill extra by token usage. When credits run out, scenarios pause until you top up — incoming webhooks queue, polling scenarios wait.

What you should know before buying

Make's learning curve is steeper than Zapier's — the canvas is powerful but takes a weekend to get fluent, and complex scenarios can become spaghetti if you're not disciplined. The credit model is cheaper at volume but demands attention: polling triggers and AI steps are the two places budgets leak.

Regional pricing varies — the figures above are the US annual-billing list; UK, EU and other regions see different price points, so check your local pricing page.

For straightforward app-to-app notifications, Zapier is faster to set up. For workflows that transform data, handle errors gracefully or run at volume, Make does more for less — that's why it's the automation community's favourite.