What actually counts as a Zapier task.

Zapier bills per successful action, not per run, so the bill tracks how many steps your Zaps take rather than how often they fire.

What each platform charges for

The billable unit decides whether your bill grows with the complexity of an automation or with how often it runs. Zapier and Make grow with complexity. n8n grows with frequency.

This page explains the shape of the pricing model rather than quoting figures, because plan limits and task allowances change. Check zapier.com for current numbers before deciding.

	Zapier	Make	n8n Cloud	Aisle
Billable unit	Task, per successful action	Credit, per module call	Workflow execution	Run, plus model calls
Trigger firing	Free	One credit, whatever it returns	Counts as the execution	Counts as the run
Adding a step	More per run	More per run	Nothing	Nothing
Doubling frequency	Doubles	Doubles	Doubles	Doubles the model calls
Iterating 1,000 rows	Roughly 1,000 tasks	Roughly 1,000 credits	Depends on loop shape	One run
Filters and branching	Free	Branch modules still count	Nothing	Nothing, it is an if statement
Cost known before deploy	Calculable, steps times runs	Calculable, modules times runs	Roughly	Yes, calls sit in the code

Billable unit

ZapierTask, per successful action

MakeCredit, per module call

n8n CloudWorkflow execution

AisleRun, plus model calls

Trigger firing

ZapierFree

MakeOne credit, whatever it returns

n8n CloudCounts as the execution

AisleCounts as the run

Adding a step

ZapierMore per run

MakeMore per run

n8n CloudNothing

AisleNothing

Doubling frequency

ZapierDoubles

MakeDoubles

n8n CloudDoubles

AisleDoubles the model calls

Iterating 1,000 rows

ZapierRoughly 1,000 tasks

MakeRoughly 1,000 credits

n8n CloudDepends on loop shape

AisleOne run

Filters and branching

ZapierFree

MakeBranch modules still count

n8n CloudNothing

AisleNothing, it is an if statement

Cost known before deploy

ZapierCalculable, steps times runs

MakeCalculable, modules times runs

n8n CloudRoughly

AisleYes, calls sit in the code

A task is a successful action, not a step.

Zapier charges for the actions it sends to other apps, and not for the routing and preparation around them, which is why cost estimates go wrong in both directions. A Zap that looks expensive on the canvas is often cheaper than it appears.

Triggers never count, however often the plan polls for them.
Filter and Paths steps are free, and a Zap stopped by a filter has run no actions, so it costs nothing.
Formatter, Delay, Looping, Digest, Storage, Tables and Forms steps are free.
A step that fails or is skipped is not billed, since nothing was sent.
Search actions count only when configured to proceed if nothing is found.
Sub-Zaps are the exception: the call and the return each count on top of the actions inside.

The bill is steps multiplied by runs.

Per-task pricing is easy to forecast and easy to underestimate, because the two numbers multiply. A six-action Zap firing a thousand times a month is six thousand tasks, and the way to halve it is usually to remove an action rather than to reduce the trigger volume.

Adding one action to a Zap that runs often is a permanent increase to the monthly bill.
Splitting one Zap into two does not save anything, since the actions still run.
A filter placed after an action has already paid for the records it discards. The same filter placed first does not.
Replaying a run recounts every step it repeats, so a bad afternoon of retries shows up on the invoice.
Error-handler paths bill like any other path once their actions run.

Where teams usually find the savings.

Most of the useful optimisations are structural rather than commercial, which is why they survive a plan change.

Move filters above the actions they gate, so the cheap step decides before the billed one runs.
Batch where the app allows it, since one action handling twenty records beats twenty actions.
Use Digest or Delay to collapse chatty triggers into one downstream action.
Watch the automations that loop, because a loop is where a small step count becomes a large task count.

When a cheaper plan does not help.

The Zaps that cost the most are often the ones that have been split, patched and split again because nobody could safely change the original. A lower per-task rate leaves every bit of that in place.

A Zap split into four to stay readable runs the same actions and bills the same.
A prompt living inside a step has no history, so a wording change cannot be reviewed or reverted.
A replay after a bad afternoon recounts every step and re-sends what already went out.
A plan change moves the rate and none of the rest.

Steps are free when they are lines.

A Task is a Python program on a managed runtime. There is no per-action meter, so the number of things an automation does is a design decision rather than a pricing one.

Model calls are the cost that scales, and they happen where you wrote them, so the per-run spend is arithmetic you can do before you deploy rather than something you learn from a usage graph.

One run regardless of how many calls the program makes.
Branching and filtering are ordinary control flow, not billable steps.
Iterating a thousand rows is a loop inside one run.
Checkpoints mean a retry does not pay again for calls that already succeeded.
Model calls sit at lines you chose, so the token spend is predictable.

score_lead.py

lead = aisle.integrations.hubspot.get_contact(
    payload["email"], id_property="email",
)

score = aisle.ai.run_prompt(slug="score-lead", variables=lead)

aisle.integrations.hubspot.update_contact(
    lead["id"], properties={"lead_tier": score["tier"]},
)
aisle.integrations.slack.create_message("#sales", text=score["summary"])

# Four calls, one run. The step count is not the bill.

Questions

What counts as a task in Zapier?

A task is a successful action step, meaning something the Zap sent to another app. Triggers do not count no matter how often Zapier polls for them, and neither do Filter, Paths, Formatter, Delay, Looping, Digest, Storage, Tables and Forms steps. Steps that fail or are skipped are not billed. Check zapier.com for current allowances, since plans change.

Do filters and paths use Zapier tasks?

No. Filters and Paths are free, and a Zap that a filter stops has performed no actions, so it costs nothing. This makes filter placement one of the few genuinely free optimisations available: a filter above an action decides before you pay, while the same filter below it pays for every record it then discards.

Why is my Zapier task count higher than expected?

The usual causes are a Zap with more actions than you remember firing more often than you think, loops turning one run into hundreds of actions, replays recounting every step they repeat, and Sub-Zaps billing for the call and the return on top of the actions inside them. Counting actions per run and multiplying by trigger volume normally explains the gap.

Is Make cheaper than Zapier?

Often, on the per-unit price, because Make charges a credit per module call and prices those credits lower. The shape is the same though: both bill per thing your automation does, so both grow with complexity. Two differences run the other way: Make charges a credit for the trigger where Zapier does not, and modules inside each active branch count, so a scenario with routers and iterators can consume faster than its step count suggests.

Is there a way to automate without per-task pricing?

Yes, by changing the billable unit rather than the vendor. Self-hosted tools move the cost to servers and the engineering time to run them. Runtime-based platforms bill for the run rather than the steps inside it, which makes the step count a design decision again. Neither is automatically cheaper, but both stop the bill scaling with how much an automation does.

Competitor details reviewed 10 August 2026. Vendors change plans and features without notice, so check theirs before deciding.

No per-task meter.

Python on a managed runtime, with a cost you can work out before you deploy.

Get started Read the SDK docs →