Zapier tasks, Make credits, n8n executions: what each automation tool counts

Six tools, four ways of counting

A Zapier “task,” a Make “credit” and an n8n “execution” do not measure the same thing. Zapier and Pabbly Connect count actions, not the trigger. Make counts every module that runs, trigger included. n8n and Activepieces count the whole run, however many steps it has. Latenode counts compute time.

Three words come up throughout this page. The trigger is the event that starts the automation (a form entry, a new row). Actions are the steps that follow. A run is one complete pass, from the trigger to the last action.

Tool	Billing unit	What is counted	For N runs of A actions
Zapier	task	each successful action, not the trigger	N × A
Pabbly Connect	task	each action, not the trigger	N × A
Make	credit (formerly “operation”)	each module run, trigger included	N × (1 + A)
n8n	execution	the whole workflow run	N
Activepieces	credit	the whole flow run	N
Latenode	CPU second	the compute time of each run	N × run time in seconds

These rules come from the six vendors’ pricing pages and documentation, recorded on the date shown; none of the tools was put through a real trial. The next table, pulled from our database, gives each tool’s unit, free plan and first paid price.

Table scrolls horizontally →

Table built from the vendors' official pages

Criterion	ZapierAutomation tool	MakeAutomation tool	n8nAutomation tool	LatenodeAutomation tool	Pabbly ConnectAutomation tool	ActivepiecesAutomation tool
Billing unit	taskssource	creditssource	executionssource	CPU secondssource	taskssource	creditssource
Free plan	100 tasks per monthsource	1,000 credits per monthsource	Nosource	10,000 CPU seconds per monthsource	100 tasks per monthsource	1,000 credits per monthsource
Lowest paid plan	$29.99 per monthProfessionalsource	$16 per monthCoresource	€24 per monthStartersource	not recorded	$19 per monthStandardsource	$20 per monthPlussource
Vendor	Visit Zapier (opens in a new tab)	Visit Make (opens in a new tab)	Visit n8n (opens in a new tab)	Visit Latenode (opens in a new tab)	Visit Pabbly Connect (opens in a new tab)	Visit Activepieces (opens in a new tab)

Make operations or Make credits?

Both words point to the same meter. Make’s help center states that credits replaced operations as the name of its billing unit (Make help center, how features use credits (accessed November 11, 2026)). An operation is still one module run and, by default, it uses 1 credit. A tutorial that talks about 10,000 operations is talking about 10,000 credits, with two exceptions covered below: the code module and agents that use Make’s AI provider.

One workflow, six meters

Take a web form. Each entry arrives by webhook (an instant trigger) and sets off four actions: add a row to a spreadsheet, create a contact, send an email, post a message in a team chat. Each run takes 5 seconds. First case: 1,000 entries a month.

Tool	Math	Units per month	Plan that covers it
Zapier	1,000 × 4	4,000 tasks	Professional, 5,000 tier
Pabbly Connect	1,000 × 4	4,000 tasks	Standard (10,000)
Make	1,000 × (1 + 4)	5,000 credits	Core, 10,000 tier
n8n	1,000	1,000 executions	Starter (2,500)
Activepieces	1,000	1,000 credits	Free (1,000, no headroom)
Latenode	1,000 × 5 s	5,000 CPU seconds	Free (10,000)

Second case: 10,000 entries a month, same four actions.

Tool	Units per month	Plan that covers it
Zapier	40,000 tasks	Professional, 50,000 tier
Pabbly Connect	40,000 tasks	Unlimited (100,000 tasks credited at the start)
Make	50,000 credits	Core, 80,000 tier
n8n	10,000 executions	Pro, 10,000 tier (no headroom)
Activepieces	10,000 credits	Plus (10,000, no headroom)
Latenode	50,000 CPU seconds	Pay as you go: 10,000 free, 40,000 billed per second

Two notes. The free plans from Zapier and Pabbly Connect cannot carry this workflow at any volume: both are limited to two-step automations, one trigger and one action. And “no headroom” means the first extra run, or the first AI step, pushes you past the quota.

The prices for these plans and tiers are listed, with the date they were recorded, in the price tables for Zapier, Make and n8n, and on the pages for Latenode, Pabbly Connect and Activepieces. The cost calculator applies the six rules to your own volume and shows the matching amount.

What runs up the meter without warning

On Make: empty polling checks and bundles

A polling trigger checks on a fixed schedule whether anything is new. On Make, each check uses 1 credit, even when it finds nothing. Over a 30-day month, that is 2,880 checks at one every 15 minutes, 8,640 at one every 5 minutes, and 43,200 at one a minute.

Go back to the 1,000-entry workflow and swap the webhook for a polling trigger. On top of the 5,000 credits for the useful runs come the empty checks: 6,880 credits in total at 15 minutes, 12,640 at 5 minutes, 47,200 at one minute. On the free plan, where the minimum interval is 15 minutes, a single scenario polling at that pace uses 2,880 credits a month against a quota of 1,000. The fix: an instant trigger when the app offers one, or a longer interval.

The second multiplier is bundles. An action module uses 1 credit per bundle it processes. If a step returns 20 rows, the next module processes 20 bundles and uses 20 credits. Routers, filters and error handlers, on the other hand, use nothing.

Zapier and Pabbly Connect do not count polling checks. For Latenode and Activepieces, this point was not recorded.

On Zapier: AI steps, MCP calls and code

Plain action steps cost 1 task each, but three kinds of step cost more. An AI by Zapier step counts as 1, 3 or 5 tasks depending on the model tier. A Zapier MCP tool call counts as 2 tasks. Code by Zapier counts as 1 task per run, plus 1 task for each 30-second block beyond the included run time. All of them draw on the same task quota as your Zaps.

On n8n: scheduled triggers

A Schedule Trigger counts one execution each time it fires. A workflow scheduled every 15 minutes therefore produces 2,880 executions a month, more than the Starter plan’s quota (2,500 executions). A webhook counts one execution per incoming request, even with an empty body. Not counted: manual executions from the editor, sub-workflows and error workflows.

On Latenode: run time

The number of steps does not matter; run time does. 1,000 runs of 5 seconds add up to 5,000 CPU seconds; the same 1,000 runs, if each waits 60 seconds on a slow API, add up to 60,000. The vendor names three things that stretch billed time: waiting on slow APIs, large files and the headless browser. On the Free plan, every execution counts for at least 1 second. The documentation also separates, in the run history, elapsed time (“Duration”) from billed time (“CPU seconds”): the second column is the one that counts (Latenode documentation, FAQ on the billing unit (accessed November 11, 2026)).

AI steps on the other tools

• Make: an agent uses 1 credit per operation, plus token-based credits when it goes through Make’s AI provider. With a connection to your own provider (paid plans), you pay that provider for tokens. The “Make Code” module uses 2 credits per second of execution and is not included in the free plan.
• Activepieces: an AI step on the models Activepieces provides costs 2, 10 or 20 credits depending on the model, or 1 credit with your own keys (from Plus). The vendor’s pages contradict each other on this point: its documentation says these calls are now billed at the provider’s actual cost, converted into credits.
• n8n: the execution stays the unit. Model calls are paid separately, with your own provider keys or Gateway credits.
• Latenode: models used without an API key are billed in “PnP tokens,” on top of CPU seconds.
• Pabbly Connect: “AI Agent” and “AI Assistant” are reserved for the Unlimited subscription; how model usage is billed was not recorded.

When you hit the limit

• Zapier: on paid plans, pay-per-task billing up to 3 times the quota, then Zaps are paused. The vendor’s pages contradict each other on the per-task rate; the exact rate is shown in the account’s billing settings.
• Make: scenarios stop until credits are added. An extra credit costs the credit price of the subscribed plan plus 25%.
• n8n: Starter and Pro are “Capped”; according to the tooltip on the pricing page, workflows keep running and these two plans have no overage fees.
• Activepieces: on Free, extra runs wait for the credits to renew; on Plus and Team, they go through and each extra credit is billed.
• Pabbly Connect: tasks are valid for 30 days and do not carry over; for more volume, the vendor suggests stacking Standard plans or moving to Unlimited.
• Latenode: beyond the free quota, “Pay as you go” has to be turned on. A monthly spending cap can be set: once it is reached, new executions fail before starting.

What this changes when you choose

• Your automations have many steps: a per-run meter (n8n, Activepieces) does not move when you add an action. On Zapier, Make and Pabbly Connect, every added action is paid for on every run.
• You poll often for only a few items: Zapier and Pabbly Connect count neither the trigger nor the checks. On Make, the checks are what weighs most.
• Your runs are long (heavy files, slow APIs, web browsing): a time-based meter like Latenode’s charges for them; a per-run meter does not.
• You are starting small: compare free plans in units, not raw numbers. 1,000 Make credits cover 200 runs of our example; 1,000 Activepieces credits cover 1,000.

The head-to-head pages redo this math two tools at a time: Make vs Zapier, n8n vs Zapier, n8n vs Make, Latenode vs n8n. The comparison of automation tools covers all six.

The vendors’ own definitions, tool by tool

Each box repeats the definition recorded, the overage rule and their sources.