Zapier suits non-technical teams wanting the widest catalogue and quickest first build, Make suits builders wanting a visual canvas and a cheaper meter; when the process ends in a decision on a case that is not ready yet, run that case on Floowed alongside either.
Whether you searched "Make vs Zapier", "Zapier vs Make" or the older "Integromat vs Zapier", this is the even-handed version: prices as both publish them at the time of writing, then the question neither tool answers, the part of automation Floowed was built for.
Make vs Zapier: what each tool is built for
Zapier is built so the person with the problem can solve it alone. A Zap is a trigger and a sequence of actions in a guided, linear editor, across 9,000+ apps, the largest catalogue in the category. It now sells itself as an AI orchestration platform: Zaps, Tables, Forms and MCP in one platform, with Agents alongside.
Make, called Integromat until February 2022, is built for the builder who wants to see the whole thing. A scenario is drawn on a canvas as modules joined by routes, across 3,000+ apps, with iterators and aggregators for line items and credits that cost a fraction of a Zapier task. Make AI Agents, the Maia assistant and Make Grid, a live map of every scenario, sit alongside it.
If the person maintaining it never wants to see a JSON array, Zapier is the correct answer. If the work is mostly reshaping data, Make usually does it in fewer, cheaper steps.
Zapier vs Make (formerly Integromat) at a glance
| Axis | Make | Zapier |
|---|---|---|
| Builder | Visual canvas of modules and routes | Guided linear editor: a trigger, then steps |
| Pricing unit | Credits: one per module action, including each trigger check | Tasks: one per successful action; triggers and built-in tools free |
| Entry paid plan | Core: $12 a month billed annually, 10,000 credits | Professional: $19.99 a month billed annually, 750 tasks |
| App catalogue | 3,000+ apps, custom apps, HTTP module | 9,000+ apps, webhooks, private integrations |
| Branching | Routers with per-route filters and a fallback | Paths: 10 branches per group, three nested levels |
| Lists and loops | Iterators and aggregators | Looping step (open beta), up to 500 iterations |
| Error handling | Five error handlers, incomplete executions | Autoreplay, an error-handler path per step |
| Waiting on a person | Human in the Loop app, Enterprise, closed beta | Human in the Loop step, paid plans |
| AI and agents | Make AI Agents (beta), Maia, MCP server, every plan | AI steps, Copilot (beta), MCP; Agents on separate plans |
| Governance | Team roles on Teams; SSO and audit logs on Enterprise | SAML SSO and audit log on Team; SCIM and app controls on Enterprise |
| Hosting | AWS, EU or North America | AWS, United States |
Make.com vs Zapier pricing: credits vs tasks as volume grows
All prices are at the time of writing (September 2026); check each pricing page before you commit. The shape of the meter matters more than the headline price.
Make meters credits. Each module action uses one: reading a record, writing a row, searching, transforming data. AI modules on Make's own AI provider are charged on tokens, custom code at two credits per second, and routers and error handlers are free. A module runs once for every bundle it receives, so a trigger that returns ten form responses makes every later module run ten times. A trigger also uses a credit on every check, found or not, so polling every five minutes spends about 8,600 credits a month before doing any work. Instant webhook triggers avoid that.
Make's Free plan gives 1,000 credits a month and two active scenarios. For 10,000 credits a month, Core is $12 billed annually ($16 month to month), Pro $21 ($28) and Teams $38 ($51); Enterprise is quoted. At 150,000 credits, Core is $129 a month billed annually. Unused credits expire at the end of the term.
Zapier meters tasks. A task is a successful action step. Triggers, polling checks and failed steps use none, and neither do the built-in tools: Formatter, Paths, Filters, Delay, Looping, Sub-Zaps, Storage, Tables and Forms. An AI step costs one, three or five tasks by model tier, an MCP tool call two, and an action after a loop one per iteration.
Zapier's Free plan gives 100 tasks a month on two-step Zaps. Professional starts at $19.99 a month billed annually ($29.99 month to month) for 750 tasks, and Team at $69 ($103.50) for 2,000 tasks and 25 users. At 10,000 tasks a month, Professional is $129 billed annually; at 100,000, $489. Past the limit, pay-per-task billing continues at a higher rate, or Zaps pause.
As volume grows, Make's lead shrinks. At 10,000 a month it costs about a tenth as much unit for unit ($12 against $129, both billed annually); at a million, less than half ($973 on Make Pro against $2,199 on Zapier Professional). It also narrows where Make charges and Zapier does not: trigger checks, and built-in steps such as iterators, aggregators and data transforms. In Make's own example, a form trigger returning ten responses followed by three modules uses 31 credits; the Zapier version runs once per response for 30 tasks. For simple, high-volume work Make usually wins the bill; for low-volume automation one person owns, Zapier's premium buys the fastest build. Either way, price the automation you will have in six months.
Integrations: 9,000+ apps vs 3,000+
Zapier wins on breadth, and the long tail is the point: the niche CRM your industry standardised on, the regional payments provider, already built and kept working when their APIs change. Webhooks on paid plans and a developer platform cover the rest.
Make lists 3,000+ apps and argues for depth instead, saying it generally exposes more actions per app. Its HTTP module and custom apps reach any public API, and Enterprise adds an on-prem agent for systems inside your network, such as SAP. The practical test: list your ten systems and check both directories.
The builder: Make's visual scenario canvas vs linear Zaps
Zapier's editor walks you through one decision at a time, so someone who has never seen a JSON object gets a Zap running in minutes, and Copilot (beta) drafts the structure from a description. The ceiling shows up in the same places: nested data, line items, Zaps that depend on each other. A Zap is capped at 100 steps, including those inside paths.
Make starts on a blank canvas, and first-time builders take longer to orient. The pay-off arrives as a scenario grows: every branch stays on screen, so complex logic is a diagram you can read rather than a chain of Zaps triggering each other.
Branching, iterators and loops
Make is the stronger tool for data-shaped logic. A router splits a scenario into as many routes as you need, each with its own filter, plus a fallback. An iterator turns an array, such as the line items on an order, into bundles that later modules process one by one, and an aggregator gathers them back. Subscenarios let one scenario call another.
Zapier has closed much of the gap. Paths allows up to 10 branches per group and three nested levels, with a fallback. Looping by Zapier (open beta) repeats the following actions up to 500 times, each iteration running in parallel as its own Zap run. Sub-Zaps reuse a sequence, and none of these logic steps cost tasks.
Error handling and retries
Make gives you the finer control. A module can carry an error route ending in one of five handlers: Skip drops the failing bundle, Retry stores it as an incomplete execution to retry automatically or by hand, Resume substitutes a value, Commit stops and keeps what was written, and Rollback stops and reverts transactional changes. Handlers use no credits. Mind the default: with no handler and incomplete executions off, a failing run rolls back, and a scenario that keeps failing is deactivated.
Zapier is more automatic. On paid plans, autoreplay retries an errored step up to five times over about ten and a half hours before emailing you, and any action step can carry an error-handler path. Failed steps use no tasks.
Both share one structural limit: their error handling is about a run failing. Neither has a concept of the run being fine and the case being incomplete.
AI and agent features: Zapier Agents and Copilot vs Make AI Agents and Maia
Zapier puts AI in four places. AI steps draft, classify, extract or summarise at one, three or five tasks by model tier. Copilot builds Zaps from a description. Zapier Agents work across the same 9,000+ apps, on separate plans: at the time of writing, 400 activities a month free, or 1,500 for $33.33 a month billed annually. Zapier MCP lets assistants such as Claude act through your apps, at two tasks per tool call.
Make builds AI into the canvas. Make AI Agents, labelled beta and on every plan, are built and debugged inside the scenario builder with their reasoning and tool use visible, on Make's AI provider or, on paid plans, your own model key. The AI Toolkit and AI Content Extractor add AI steps, the Make MCP server exposes scenarios as tools, and Maia builds by conversation.
Human in the loop. Zapier's Human in the Loop step pauses a Zap run until a reviewer approves, declines or edits the data, notifying by email, Slack or another Zap, with reminders and a timeout set in minutes, hours, days or weeks. Make's Human in the Loop app creates a review request that a separate trigger picks up once completed; at the time of writing it is an Enterprise app in closed beta.
Credit where it is due: both can now pause for a person and put an agent mid-automation. Neither changes the unit of work. The agent acts inside a run, one reviewer completes the approval, and Zapier's own FAQ admits agent outcomes vary because language models are non-deterministic. Fine for drafting a reply; a problem when the step is the decision.
Governance, security and hosting
Zapier's admin controls go further. Team adds 25 seats, a shared workspace, folder permissions, SAML single sign-on and an audit log. Enterprise adds SCIM provisioning, app access controls, action restrictions, custom data retention and approval before a Zap can be published. Zapier holds SOC 2 Type II and SOC 3 reports and hosts data on AWS in the United States.
Make gives every plan unlimited users and adds team roles on Teams. Company single sign-on (OAuth2 or SAML2), audit logs, custom roles and the on-prem agent sit on Enterprise, in a separately managed AWS environment under an ISO 27001-certified security programme. Make holds SOC 2 Type II and SOC 3 reports and runs in an EU or North American region.
Ask both the same question early: what evidence survives a call? Execution history (Make keeps 30 days on Core, Pro and Teams) shows that a step ran, not which version of the rule was live or why the case came out the way it did.
Make vs Zapier: how the choice resolves by buyer type
- Operations, marketing or sales lead without engineers: Zapier. The guided editor and the 9,000-app directory get you further alone.
- RevOps or FinOps builder working with line items and lookups: Make. One readable scenario does what takes several Zaps.
- High volume and cost-sensitive: Make, on webhook triggers rather than polling.
- IT owner governing automation across departments: Zapier Enterprise for app and action controls; Make Enterprise for the on-prem agent, with EU or North American hosting on every Make plan.
- Run both: Zapier for departmental automations, Make for the data-heavy scenarios a builder owns.
Weighing n8n too? See n8n vs Zapier and n8n alternatives.
The question neither Make nor Zapier answers
Everything above compares two good answers to one question: how does data get moved between systems. There is a second question that looks the same and is not: how does this case get decided. An invoice needs approving. A supplier wants onboarding. A contractor needs clearing before Monday. Something has to be gathered, read, checked against your rules and settled.
Take the invoice. It arrives without a PO number. The PO turns up, and the amount does not match the goods receipt. The budget holder who must approve the difference is away for a week. None of that is an error. It is the normal life of a case.
A scenario or a Zap is built around a run. Make caps an execution at 40 minutes on paid plans; Zapier can hold a run on a Delay step for up to 30 days, or pause it for one reviewer with reminders and a timeout. What a run does not hold is the case: which pieces are outstanding across people and systems, who owes each one, what counts as an answer, and how the case picks up at the right gate when the answer lands. So builders assemble that from data stores or Tables, a second scenario to catch replies and a reminder schedule, and the tell is the sheet beside it tracking who you are waiting on. We see it in almost every operations team we talk to.
Where Floowed fits alongside Zapier or Make
The architecture that works is a division of labour. Keep Zapier or Make for triggers, moving data and the last mile into your CRM or ledger. Put the case somewhere built for cases.
Floowed is the decision platform. Underneath is an AI-native, multi-agent runtime, model-agnostic, routing work between open-weight and frontier models on cost, latency and data residency. Every case runs gather, interpret, chase, decide, act, from intake to outcome. Three input lanes feed it as equals: your systems, over the API, MCP and 400+ integrations across every industry we serve; external sources such as registries and KYC providers; and documents, read in whatever state they arrive and cross-checked against the rest of the case. When a piece is missing, the case chases the named person, system or agent who owes it, waits as a long-running asynchronous case, and resumes on the answer, whether it comes back in an hour or in days.
The rules live in one place, not scattered across routers and paths. The Decision Engine is a deterministic policy engine: your rules, versioned, and back-tested against past cases and their real outcomes before a change goes live. You set the thresholds: settle it automatically, route it for review, or raise it as an exception. What comes back is a decision with the evidence behind every check, on a versioned decision record. Floowed sits above your systems of record as the system of action: they stay, they just stop being where the work happens.
| On a case that is not ready yet | Make | Zapier | Floowed |
|---|---|---|---|
| Unit of work | A scenario run, up to 40 minutes | A Zap run, held up to 30 days on a Delay step | A long-running asynchronous case, open until decided |
| Waiting on a person | Review request, picked up by a separate trigger | One reviewer approves, declines or edits, with a timeout | Chases whoever owes each piece, person, system or agent, and resumes on the answer |
| Where the rules live | Filters and routers inside scenarios | Filters and Paths inside Zaps | A deterministic policy engine, versioned and back-tested |
| What comes back | Execution history | Zap history and versions | A decision with the evidence behind every check |
| Meter | Credits per module action | Tasks per successful action | Credits for the work done on a case, $80 free |
The handover is a webhook or API call each way: a Zap or scenario opens the case, Floowed calls back when the decision lands, and a second Zap or scenario does the downstream work. Your own agents can open a case over MCP, the way your team opens one by hand. See the Zapier integration and Make integration.
Start from a library flow (invoice approval, supplier onboarding, vendor risk review, customer onboarding, employee offboarding, claims intake, contractor clearance, refunds and goodwill), adapt it to your systems and rules, and run cases through it. We charge credits for the work done on a case, not for seats: $80 of credits free, no card and no sales call, then $80 to $2,000 a month at one rate. See pricing, and decisions for a flow running.
Frequently asked questions
Is Make better than Zapier?
Neither is better in general. Zapier is faster to start, connects to 9,000+ apps against Make's 3,000+, and suits builders who are not technical. Make is cheaper unit for unit, handles arrays, iterators and multi-route logic more naturally on its visual canvas, and can run in an EU region. The choice usually comes down to who maintains the automation in a year and how much volume it carries.
Is Make cheaper than Zapier?
Per unit, yes, though the gap narrows with volume. At the time of writing, 10,000 Make credits cost $12 a month billed annually on Core, while 10,000 Zapier tasks cost $129 billed annually on Professional. The units differ: Make charges for every module action, including each polling check, and modules after an iterator run once per item, while Zapier's triggers, filters, paths and looping steps are free. Price both against your own volume.
Is Make the same as Integromat?
Yes. Integromat relaunched as Make on February 22, 2022, with a new brand and a rebuilt platform, and Make announced that support for the legacy product would end in 2023. The core ideas carried over: scenarios on a visual canvas, built from modules, routers and iterators. So "Integromat vs Zapier" is now the Make vs Zapier question, with credits as Make's billing unit and AI agents on top.
What is the difference between Make credits and Zapier tasks?
A Make credit is one module action, such as reading, writing or transforming data, and a trigger uses one every time it checks for new data. Routers and error handlers are free; Make's own AI provider charges on tokens. A Zapier task is one successful action step. Triggers, polling, failed steps and built-in tools such as Paths, Filters, Formatter and Looping use none, while AI steps cost one to five tasks by model tier.
Do Zapier and Make have AI agents?
Both do. Zapier Agents work across Zapier's 9,000+ apps on separate, activity-based plans, alongside AI steps, Copilot and Zapier MCP. Make AI Agents, still labelled beta, are built and debugged inside the scenario canvas on every plan, with Maia for conversational building and a Make MCP server. In both, the agent acts inside a run and its output can vary between runs, so a step that decides a case still needs explicit, versioned rules behind it.
Can Make or Zapier wait for an approval?
Within limits. Zapier's Human in the Loop step pauses a Zap run until one reviewer approves, declines or edits, with reminders and a timeout, and a Delay step can hold a run for up to 30 days. Make caps an execution at 40 minutes on paid plans, so waiting spans scenarios, using its Human in the Loop app (Enterprise, closed beta). Zapier pauses a run and Make hands off between scenarios; neither is built to hold a case open across several people, systems and missing documents.
Can Zapier or Make call Floowed?
Yes, in both directions, and neither needs replacing. A Zap or scenario opens a case by posting to Floowed over a webhook or the API; Floowed calls back with the decision and its evidence, and a second Zap or scenario acts on it. In between, the case runs on Floowed's multi-agent runtime as a long-running asynchronous case, chasing whatever is missing. A deterministic policy engine then applies your versioned rules. Your own agents can open cases over MCP. On the Zapier side, webhooks need a paid plan.
Try it on a case your automation cannot finish
Take one decision your team still makes by hand, the one with the chasing and the spreadsheet beside it, and run it. Start free with $80 of credits, no card and no sales call, and connect it to the Zap or scenario you already have. Invoice approval is a good first one.
Or book a demo and name the decision. We will show a case being gathered, interpreted, chased and decided, including when the answer never comes.