Make vs Zapier comes down to who maintains the workflow and how much of it branches. If the owner wants to read the workflow top to bottom without learning a canvas, the workflow has three or four steps, and one of your apps exists only in Zapier's larger catalogue, choose Zapier. If the workflow branches, loops over line items, or runs thousands of times a month, choose Make: it bills less per run and draws branching as branching. If you need to run it on your own servers, choose neither, because both run only in their own cloud; self-hosted n8n is the usual answer, compared in n8n vs Make. All prices below come from make.com/en/pricing and zapier.com/pricing, read on 2026-10-07.
| Make | Zapier | |
|---|---|---|
| Price from (unit) | Core $9/month annual, $10.59 monthly, for 10,000 credits; 1 credit = 1 module run | Professional $19.99/month annual, $29.99 monthly, for 750 tasks; 1 task = 1 successful action |
| Free tier | 1,000 credits/month, 2 active scenarios, 15-minute minimum interval, routers and filters included | 100 tasks/month, two-step Zaps only (one trigger, one action), 15-minute polling |
| Hosting | Make's cloud on AWS (EU or North America); On-prem Agent on Enterprise reaches local systems | Zapier's cloud only |
| Who it fits | Workflows with branches, loops and many steps; volume in the thousands of runs | A non-technical owner, short workflows, long-tail SaaS apps |
| Who it does not fit | An owner who will not learn the canvas or read a module's bundle output | High-volume or many-step workflows, where every action adds to the bill |
| Where it gets hard | Credits are hard to predict: polling checks and iterators multiply them | The bill climbing with each step added; Professional is one seat |
The INITE Atlas keeps a card for each, Make and Zapier, with the pricing source and the date it was read.
What does each one count as a billable unit?
The unit decides the comparison, so it is worth being exact.
Make counts credits. Its pricing page says each module action in a scenario counts as one credit: reading, searching, creating, updating or deleting data, transforming it with built-in tools, and aggregating or iterating it. Code costs 2 credits per second of execution. Two kinds of module cost nothing: error handlers (Rollback, Break, Resume, Commit, Ignore) and the router.
Two rules in Make's help center change the arithmetic. First, a trigger module costs one operation per check, whether or not it finds anything. Second, every module runs once per bundle it receives, so a step that returns five items makes every module after it run five times. That is how a scenario "can perform anywhere from two credits to thousands of credits in a single run," in the words of Make's pricing FAQ.
If you run out, scenarios stop until credits are added; webhooks queue up to your storage limit and polling triggers pick up from the last successful run. You can buy extra credits in bundles of 1,000 or 10,000 at your plan's rate, or switch on auto-purchase. Credits expire at the end of the term.
Zapier counts tasks. A task is used when a Zap "successfully moves data or completes an action." Triggers, polling and a list of built-in tools use none: Formatter, Paths, Filters, Delay, Looping, Sub-Zap, Digest, Storage, Tables and Forms. Standard action steps, AI actions, Code steps and programmatic calls through MCP or the SDK all count. Failed actions do not. The allowance resets monthly, even on an annual plan. When you hit the limit, Zapier moves you to pay-per-task billing "at a higher per-task rate," or pauses the Zaps until the next period if you have turned that off.
The short version: Make charges for the trigger and for data transformation and charges nothing for the router, while Zapier charges for neither the trigger nor the transformation and nothing for paths.
What does the same workflow cost on each?
Take one workflow, lead routing, which is one of the business process automation examples most likely to pay back first. A web form posts a lead to a webhook (trigger). The CRM is searched for the contact. A router splits the run: a new contact is created, an existing one is updated. Either way the sales channel gets a Slack message. On the path any single run takes, that is five steps: trigger, search, router, write, message.
On Make: trigger 1 credit, search 1, router 0, write 1, message 1. That is 4 credits a run. At 2,000 runs a month, 8,000 credits, which fits the 10,000-credit Core plan: $9 a month billed annually or $10.59 monthly.
On Zapier: trigger 0, search 1 task, Paths 0, write 1, message 1. That is 3 tasks a run. At 2,000 runs, 6,000 tasks. The 5,000 tier is too small, so the plan is Professional at 10,000 tasks: $129 a month billed annually ($1,548 a year) or $193.50 monthly. The alternative is the 5,000 tier ($89 annual, $133.50 monthly) plus 1,000 tasks at the pay-per-task rate, which the pricing page describes as higher but does not print next to the tiers. The plan data behind the page puts it at 2.23 cents a task on the annual 5,000 tier, so that route comes to about $111 a month, less than the 10,000 tier, with every month then running on overage.
Two things we could not settle from the published terms, so check them before you size a plan. On Zapier, whether a CRM search that finds nothing counts as a task (the page says unsuccessful actions do not count, but a search with no result is not obviously a failure), and the page also warns that "some apps or actions may use more than one task." On Make, the pricing page does not say whether a filter costs anything; a filter sits on the link between modules rather than being a module, and a filter that stops a bundle saves the credits of every module after it.
The trap on Make is the trigger. The example uses a webhook, which runs once per lead. Swap it for a trigger that polls, say "watch new rows" in a spreadsheet, and each check costs a credit even when there are no rows. Checking every 15 minutes is 2,880 checks in a 30-day month; the scenario then uses about 2,880 + 6,000 = 8,880 credits and still fits the $9 plan. Checking every minute is 43,200 checks, about 49,200 credits, and the plan becomes the 80,000-credit Core tier at $55 a month annual or $64.71 monthly. Zapier never charges for polling, so the same switch costs nothing there.
Which is cheaper at 500, 2,000 and 10,000 runs a month?
The same workflow, 4 credits or 3 tasks a run, on each vendor's cheapest plan that holds it. Prices are per month; pricing pages read 2026-10-07.
| Runs a month | Make credits | Make Core (annual / monthly) | Zapier tasks | Zapier Professional (annual / monthly) |
|---|---|---|---|---|
| 500 | 2,000 | $9 / $10.59 (10k tier) | 1,500 | $39 / $58.50 (1,500 tier) |
| 2,000 | 8,000 | $9 / $10.59 (10k tier) | 6,000 | $129 / $193.50 (10k tier) |
| 10,000 | 40,000 | $29 / $34.12 (40k tier) | 30,000 | $289 / $433.50 (50k tier) |
Neither free plan holds this workflow. Make's 1,000 free credits cover 250 runs. Zapier's free plan allows only two-step Zaps, and a search plus a write plus a message is four.
If more than one person builds, the plans change on both sides. Zapier Professional is one seat; Team starts at 2,000 tasks for $69 a month annual ($103.50 monthly) for up to 25 users, and its 10,000 and 50,000 tiers cost $169 and $399 annual. Make's Teams plan costs $29 annual ($34.12 monthly) at 10,000 credits and $99 annual ($116.47 monthly) at 40,000.
At every volume here Make is cheaper by a multiple, and the gap widens with each step you add, because Zapier's tier price climbs with tasks faster than Make's does with credits. Platforms that bill per run widen it further, as the pricing in zapier alternatives shows. What would close it: a workflow made mostly of Zapier's free built-in tools (Formatter, Filters, Paths), or a Make scenario with a fast polling trigger or an iterator over long lists. Before you compare quotes for either, the questions in how to read an automation quote apply to a subscription as much as to a build: count the monthly runs from your own systems first.
Who builds the workflow, and who keeps it running?
This matters more than the price difference for most small teams, because a workflow nobody can read is one nobody fixes.
Zapier's editor is a list. The trigger is at the top, the steps run downward, and a path appears as an indented branch. Someone who has never seen the Zap can read it in order and understand it. That is the main reason to pay Zapier's prices: the person maintaining it in a year may not be the person who built it, and may not be technical.
Make's editor is a canvas. Modules are circles joined by lines, routers fan out into branches, and each module shows the bundles it processed in its last run. For branching logic that picture is clearer than a list. The cost is a learning curve: a maintainer needs to understand bundles, mapping and why a module ran 40 times, or a failed run is unreadable to them. A Hacker News commenter described that trade for Zapier, IFTTT and Make alike:
They provide a visual pipeline/flowchart that any stakeholder can follow as an outline, even if they can't necessarily understand every node.
- solardev, Hacker News, 14 February 2024 (link)
The useful question is who will own the workflow after the person who built it moves on. If you cannot answer it, sort that out before picking a tool; deciding what to automate first starts there for the same reason.
Which handles complex logic better?
Make, for anything past a single branch.
Make has routers, filters on each route, iterators that split an array into separate bundles, and aggregators that join them back. All are included on the free plan. A scenario that takes an order with ten line items, processes each one and writes a summary is a standard Make pattern. The catch is cost: everything after the iterator runs once per item.
Zapier has Paths for branching, Filters to stop a run, and Looping to repeat steps over a list, none of which use tasks themselves. The actions inside a loop still count one task per successful action per pass, so ten line items through two actions is twenty tasks. Multi-step Zaps, Paths and Filters need a paid plan.
Make also allows up to 40 minutes of execution per run on paid plans (5 minutes on Free), which matters for long batch jobs.
What happens when a step fails?
Both retry; they differ in how much of the retry you design.
On Make, error handling is part of the scenario. You attach an error handler to a module, and the five directives decide what happens: roll back, break, resume with a substitute value, commit what has run, or ignore. Error handlers cost no credits. A Break stores the failed run as an incomplete execution, and Make's help center says it retries rate-limit, connection and timeout errors automatically on a backoff schedule from 1 minute to 3 hours. You can see each incomplete execution and resolve it by hand.
On Zapier, failed actions do not use tasks. Autoreplay, on Professional and above, replays errored Zap runs automatically, and paid plans can customize error settings per Zap. One cost to know: replaying a whole Zap run counts its tasks again, even those that succeeded the first time. Zapier also turns a Zap off by default if it errors on nearly every run over a week.
Neither of them protects you from the failure that does not raise an error: the API that starts returning a different shape and the workflow that keeps running on wrong data. That class of problem is described in when the integration changes underneath you, and it needs someone reading the output, not a retry setting.
Does Zapier really have more integrations?
By count, yes. Make's pricing page lists 3,000+ apps; Zapier's lists 9,000+. For mainstream tools (Google Workspace, Slack, the big CRMs, Stripe, Shopify) both have connectors, and the count does not decide anything. It decides when your stack includes a niche SaaS product: check that exact app on both directories before anything else, including which triggers and actions it supports, since a connector that exists but lacks the trigger you need is no connector at all.
One piece of our own data, with a caveat. The INITE Atlas scores how well a vendor's own website can be found, resolved and quoted by AI retrieval engines. On 2026-10-07 zapier.com scored 96 and make.com 47. That measures the vendors' websites, not the products, but it has a practical side: when you ask an AI assistant how to do something in Make, it has less of Make's own documentation to quote.
Which has better AI agents?
Both are building the same set of features, and both charge for AI inside the same meter.
Make lists, across all plans: Maia (build scenarios through conversation), Make AI Agents (in beta on the pricing page), the Make MCP Server, an AI content extractor, AI web search (beta) and an AI toolkit. AI modules that run on Make's own AI provider are billed on tokens as well as operations, so they can use more than one credit per run; if you connect your own OpenAI or Anthropic account on a paid plan, Make bills operations and you pay the model provider.
Zapier lists, across all plans: Zapier Agents and Chatbots (basic access, with paid add-ons), Canvas, Zapier MCP and Copilot (with a daily message limit on Free). AI by Zapier, AI fields in Tables and Formatter with AI need Professional or above. AI actions and MCP calls count as tasks.
Neither pricing page lets you price an AI-heavy workflow in advance with certainty, because the per-run cost depends on the model and the tokens. If the AI step is the point of the workflow, run a week of real volume on a trial and read the meter before committing; the ROI arithmetic for automation is unreliable without that number.
What does switching cost?
More than people expect, in both directions. There is no import between them. A Zapier path becomes a Make router with filters on each route, a loop becomes an iterator and an aggregator, and the billing unit changes, so the plan has to be re-sized from scratch with the arithmetic above. Each connection has to be re-authorised, each field mapping redone, and each workflow re-tested on real data.
The rebuild is a chance to remove steps nobody needs. Run old and new in parallel for a week, compare outputs, and switch off the old one only when they match.
How to choose
Count three things before you open either pricing page: monthly runs, billable steps per run, and whether the trigger is a webhook or a poll. Then name the person who will maintain the workflow.
If that person is not technical and the workflow is short, pay for Zapier: the readable list is worth the difference at low volume. If the workflow branches or loops, or the run count is in the thousands, choose Make and use webhook triggers wherever the app offers them. If the workflow must run on your own infrastructure, neither is the answer.
Otherwise the deciding rule is this: price the workflow you actually have on both meters, and take Make whenever its bill comes out lower by more than the hours your maintainer would need to learn the canvas.
Top comments (0)