Make vs Zapier: Tasks, Credits, and What a Real Workflow Costs

Make and Zapier sell the same thing (thousands of app connectors, triggers that set off actions, a free tier to start on) and then bill it two different ways. Zapier counts tasks. Make counts credits. A task and a credit cover different ground, so one automation can land at very different monthly totals depending on which one is doing the counting. The headline prices only hint at the gap: about $10 gets you roughly 10,000 credits on Make's Core tier, while $19.99 gets you 750 tasks on Zapier's Professional tier.

Where those two counters charge you is the whole story, and it changes depending on whether your automation is short and light or long and busy. Start with what each counter books.

How each platform counts a run

Zapier charges by tasks. A task is each action step a Zap completes successfully, and the trigger that starts it is free. The free plan gives 100 tasks a month with unlimited Zaps, but those Zaps are capped at two steps and poll every 15 minutes. The first useful paid tier is Professional at $19.99/mo, which adds unlimited multi-step Zaps, premium apps, webhooks, and 2-minute polling, with a starting allowance of 750 tasks a month that scales up as you pay more. That $19.99 is the annually billed price, and annual billing saves about a third versus paying month to month. Above Professional, Team starts around $69/mo and adds up to 25 users, shared workflows, SAML SSO, 1-minute polling, and priority support. Enterprise is a custom quote.

Make charges by credits, which it renamed from "operations" in 2025. One standard module action costs one credit. The free plan gives 1,000 credits a month, 2 active scenarios, and a 15-minute minimum interval. Paid starts at the Core plan, about $9/mo billed annually (roughly $12/mo month to month), which brings 10,000 base credits, unlimited active scenarios, a 1-minute minimum interval, and access to the Make API. Pro, about $16/mo annually, layers on priority execution, searchable full-text logs, and custom variables. Teams is about $29/mo annually and adds multiple users, team roles, and shared templates. Enterprise is custom, with SSO and advanced security. Annual billing saves 15% or more across the paid tiers.

The summary at a glance

When the workflow is short and light

Picture a plain "when X happens, do Y" automation running at low volume. On Zapier this is cheap and easy to predict. A two-step Zap is a trigger plus one action, so it books one task per run; fire it 100 times a month and you sit inside the free 100-task allowance. Zapier also does not charge tasks for filters, formatters, paths, or logic, so adding a little branching to a light workflow does not move the bill. That predictability is the point of the flat task rate.

The same light workflow can tally credits on Make that you did not plan for. Even a filter that blocks the flow still spends one. Every time a polling trigger looks for new data, that's another credit gone, and polling once a minute racks up roughly 43,200 of those checks monthly before any action even runs. None of that is expensive on its own, but for a simple, low-volume job it can pull Make's cheaper-looking credits back toward Zapier, so the two land closer than the headline prices suggest.

When the workflow is long and busy

Now stack the steps and the volume, and the counting turns in Make's favor. Credits scale with modules times runs, but the traps sit in the details. Loop items are billed one at a time: 12 items pushed through a four-module loop is 48 credits, not 4. The steps that already ran inside a failed execution still count. And when you exceed your credit quota, Make does not pause your scenarios; it quietly tops up your balance at a 25% surcharge and puts it on your invoice, which keeps automations alive but lets a busy month cost more than the plan you signed up for. Between metered filters, polls, loops, and that overage behaviour, Make is the harder bill to forecast at scale.

The flip side is a low per-unit price. On raw volume per dollar, Make is the cheaper counter to feed for step-heavy, high-volume automations: its Core tier's 10,000 operations for around $10 dwarfs Professional's 750 tasks at $19.99. That is a pattern rather than a promise; some real-world comparisons have actually run cheaper on Zapier, so it always turns on the specific workload.

What the credits are paying for

Make counts so many things because it does so much more per scenario, and that extra power is what the credits buy. Complex logic in a single workflow is the headline. Make's canvas natively handles routers for branching, iterators for looping over lists, and aggregators for combining data back together, all wired into one scenario. Zapier's linear model can do paths and loops, but it gets clunky, and heavier branching often forces you to split the work across several separate Zaps.

Because the whole data flow sits on a canvas, you also get visual debugging: you can watch a scenario run, inspect the input and output of each module, and replay a step to see what it did. Zapier uses a linear step list instead. Data transformation goes deeper in Make, with native JSON parsing, array iteration, regex, and mapping tools where Zapier leans on its simpler formatter steps. Error handling includes directive-based handlers (Resume, substitute data, Rollback, Commit and Break) plus automatic retries, wired into the scenario itself. A universal HTTP and webhook module can call any REST API even when no native connector exists. That is the trade against Zapier's counter: Make meters the polls, filters, and loop items that Zapier leaves uncounted, and in exchange every credit runs through a canvas that branches, loops, and transforms in ways a linear Zap cannot. It suits agencies, ops and automation builders, and visual thinkers who are willing to learn it.

What the flat task rate is paying for

Zapier charges more per unit and covers fewer power features, and in exchange it removes friction. App coverage is the clearest edge: Zapier's site cites 9,000+ connected apps, against Make's roughly 1,800 to 2,400 (the exact count is disputed). For long-tail or niche SaaS tools, Zapier is far more likely to have a native integration ready.

Speed to a working automation is the other one. Zapier's linear editor and template library reduce the setup needed for a simple trigger-and-action workflow, while Make exposes the whole flow on a canvas. AI-assisted building through Copilot lowers Zapier's setup burden further, and filters, formatters, paths, and logic do not count as tasks, the exact steps Make meters. So the flat task rate buys the opposite trade: fewer power features per run than Make's canvas, but a wider app catalog, a faster first automation, and a bill that only moves when real action steps fire. Zapier also documents SOC 2 Type II, ISO 27001, GDPR, and SSO on higher tiers, which matters to teams with procurement requirements.

Put the same job through both counters

Take one automation and run it through each counter. A five-step workflow fired 1,000 times a month books 5,000 credits on Make, comfortably inside Core's 10,000-credit allowance for about $10. The same five steps on Zapier are four action steps past the free trigger, so roughly 4,000 tasks, which blows past Professional's 750-task starting allowance and climbs its paid ladder. Same work, two counters: at this volume and step count, the credit counter is the cheaper one to feed, and that single calculation is the argument in a nutshell.

The recommendation

Pick Make if your automations have real shape to them: multiple branches, loops over line items, data that needs transforming on the way through. Its canvas is built for exactly that work, and its credits cost far less per unit once volume climbs. The trade is a steeper first afternoon and a bill that takes more care to forecast. Our Make guide covers the setup basics, and if self-hosting tempts you, weigh Make vs n8n before you settle.

Pick Zapier if what you need is a reliable A-to-B automation running today. The linear editor gets a first Zap live in minutes, the 9,000+ app catalog means your niche tools are probably already covered, and the flat task rate keeps the bill predictable. You pay more per unit for that simplicity, and heavily branched pipelines will eventually feel cramped, but for simple glue between apps it stays the quickest answer.

FAQ

Which one ends up cheaper for the same workflows?

What decides it is how your workflows run, not the sticker number on the pricing page. Per dollar, Make hands you more volume: its Core tier is roughly 10,000 operations for about $10, against Zapier Professional's 750 tasks for $19.99, a per-unit gap that favors step-heavy, high-volume automations. Because the two count usage differently, and Make charges credits for polling, filters, and loop items that Zapier leaves uncounted, a simpler or lower-volume setup can close that gap. Your real workflow volume is the deciding factor.

Tasks vs credits: what counts as one?

Zapier books a task for each action step a Zap completes, and the trigger runs free. Make books an operation (a credit) for every module that fires. A five-step Make scenario run 1,000 times comes to 5,000 operations, while Zapier tallies tasks per successful action step. Credits tend to be cheaper per unit, which is why Make usually wins on high-volume, multi-step work and Zapier wins on simple, low-volume ease.

How quickly can a non-technical person get started?

Faster on Zapier. Its linear, step-by-step editor lets most people build a first automation in minutes with no training, and that easy onboarding is its clearest edge. Make's visual canvas does more but climbs a steeper curve; budget a few hours before it feels productive. If you are non-technical and want something live today, begin with Zapier.

Which one holds up on branching, multi-step pipelines?

Make. Its canvas natively runs multi-branch routing, iterators and aggregators for looping over and recombining data, and directive-based error handling, all inside one scenario. Zapier manages paths and loops but turns clunky and tends to run out of road on sophisticated pipelines, sometimes making you split the work across several Zaps. For heavily branched, data-transforming automation, Make is built for it.