Zapier, automation where you pay for every step

Zapier, automation where you pay for every step

Zapier connects applications into event driven automations: something happens in one system and Zapier performs an action in another. The largest catalogue of ready integrations in its category, the simplest start, and billing that can surprise you if the design is careless.

How task billing works

This is the most important thing to grasp before building anything, because it shapes how you design an automation.

A task is every action Zapier performs on your data. An automation with one trigger and three actions consumes three tasks on every run, not one. At a hundred events a day that automation eats nine thousand tasks a month.

Not everything counts toward the limit, and that is worth exploiting. Filters, conditional paths, data formatting, delays, and the built in tables and forms are free. You pay only for actions reaching into external applications.

The design conclusion is concrete: filter as early as possible. An automation that fetches data first and only then checks whether it is needed pays for every fetch. The same logic with a filter up front pays only for the cases that actually proceed.

Pricing

The free plan carries a limit more consequential than the task count: an automation can have only two steps, meaning a trigger and one action. Any process needing a condition or a second action forces a paid plan regardless of volume.

Set the task slider on the professional plan deliberately, since the price rises with it. Start at a threshold matching last month's real usage and raise it only once run history shows the allowance genuinely running out. Setting a high threshold as a buffer is a reliable way to pay for tasks nobody consumes.

Annual billing can mislead, since the price quoted in comparisons is usually the rate when paying a year up front. On monthly billing the professional plan costs about 29.99 USD, so the gap reaches a third.

Your first automation

A typical process consists of a trigger, a filter, and actions. Their order matters for cost, not only for logic.

Take handling form submissions: a new entry lands in a spreadsheet, needs a priority assessment, and only urgent ones should reach the team channel. The cheap layout runs: trigger on a new row, filter on the priority field, then the notification. The expensive layout runs: trigger, notify everyone, and filter on the receiving end.

Test with sample data before switching an automation on. The editor shows a sample record from the source and the output of each step against it, so a field mapping mistake surfaces before the first real run. That is five minutes saving an hour of cleaning up after an automation that sent something to the wrong place.

For integrations absent from the catalogue there is the HTTP request step. You call your own API, pass data from earlier steps, and process the response.

{
  "url": "https://yourapi.com/tickets",
  "method": "POST",
  "headers": { "Authorization": "Bearer {{key}}" },
  "data": { "email": "{{step1.email}}", "priority": "{{step1.priority}}" }
}

That step counts as a task, but it opens access to anything with an API, so a missing prebuilt integration stops being an obstacle.

AI agents and Zapier MCP

Beyond classic automations, the platform offers two things worth telling apart.

Agents carry out tasks described in natural language, deciding for themselves which tools to use. They bill separately, in activities rather than tasks: the free threshold is four hundred activities a month, and the paid plan starts around 33 USD for fifteen hundred. It is a separate add on rather than part of the base plan.

Zapier MCP exposes the platform's integrations to assistants supporting the Model Context Protocol, Claude for instance. The model can then trigger actions in your applications with no integration code written. The feature is included in the plan, but every call costs two tasks, so an assistant checking a calendar a dozen times a day noticeably draws down the allowance.

A practical note: an agent is often the most expensive way to do something a condition could express. Before letting one into a process, check whether the task genuinely requires a decision or merely looks complicated.

What else sits inside the platform

Zapier stopped being purely a connector between applications, and it helps to know what you get without adding more tools.

Tables are a lightweight database inside the platform. They work as a home for data with no system of its own: a list of tickets to handle, a register of sent messages, simple process state. Table operations do not count toward the task allowance, so keeping state there is cheaper than querying an external database on every run.

Forms collect data straight into an automation with no intermediary. For a simple submission or a sign up list they save an entire integration layer with an external forms tool.

Interfaces let you build a simple page with a form and a data view, meaning a minimal internal tool with no frontend written. It suits processes handled by a few people rather than a product for customers.

Putting all three together looks like this: a form collects a submission, a table holds its state, an interface shows the list to whoever handles it, and an automation notifies the right team. The whole thing sits in one tool, and only the last step counts toward the task allowance.

The limitation is that these pieces are deliberately simple. When a table starts needing relations and an interface needs field level permissions, that is the signal the process outgrew the platform and it is time for a real application.

Zapier against the alternatives

The practical rule runs like this. Up to ten processes with short paths, Zapier is cheapest in time terms, because it works immediately and needs nothing beyond an account. At twenty step processes or high volume, per step billing starts losing to per run billing.

Integration count can settle the question too. If your process touches a niche industry tool, Zapier carries it more often than the alternatives, and writing that integration yourself costs more than a year of subscription.

Work out the crossover on your own numbers. A ten step process triggered a thousand times a month is ten thousand tasks in Zapier and a thousand runs in a per run tool. Across a year that gap often exceeds the cost of standing up your own instance.

How to avoid overpaying

A few habits lower the bill more than changing plan does.

Filter at the start, not at the end. That single change has the largest impact, since it eliminates tasks for cases that get discarded anyway.

Use a webhook instead of a polling trigger wherever the source offers one. Checking every five minutes around the clock is nearly nine thousand checks a month, even when real events number a few dozen.

Group actions. Three separate automations reacting to the same event consume three sets of tasks, while one automation with three actions consumes the same total but is easier to maintain and cheaper to extend with a shared filter.

Use the free steps. Text formatting, date arithmetic, branching, and delays do not count toward the allowance, so move logic into them rather than into external services.

Switch off automations nobody uses. A process built for one campaign can keep running a year after it ended, quietly consuming the allowance.

Review run history once a month. An automation failing and retrying can eat the allowance without delivering anything.

When Zapier stops being enough

The tool has a clear range, and it pays to recognise when a process outgrows it. Four signals show up most often.

The first is a bill growing faster than the number of cases handled. If adding a step to a process raises the monthly cost by a noticeable amount, the billing model has started working against you and the alternative deserves a calculation.

The second is logic that conditions cannot express. Looping over a list, a calculation depending on several sources at once, or error handling that needs a delayed retry are things that come out contorted in a visual editor and trivial in a few lines of code.

The third is a process count exceeding the team's ability to hold it in their heads. Thirty automations with no naming scheme, no documentation, and no owner is a system where nobody knows what breaks when one gets switched off.

The fourth is data requirements. A process handling personal data or covered by a customer agreement demands an answer to where that data sits and for how long, and with an external tool the answer is not always satisfying.

A sensible exit path does not mean rewriting everything at once. Move the most expensive process to a per run tool or to your own code, measure the difference over a month, and only then decide about the rest. Some processes usually stay in Zapier permanently, because for short paths it remains the cheapest option in time terms.

Common mistakes

The first is no error handling. An automation that stopped working does not announce it, and a customer ticket disappears quietly. Set failure notifications on every process touching customer data.

The second is testing in production. A trigger wired to real events can fire dozens of messages on its first run before you notice a fault in the condition.

The third is assuming a fixed data shape from an external API. The vendor adds a field or renames one, and a step configured around the old shape stops working or, worse, starts passing empty values.

The fourth is one automation covering every case. A process with six branches is illegible and cannot be tested in pieces.

The fifth is keeping keys in text fields rather than in connections. A value typed into a URL lands in the run history, visible to anyone with account access.

FAQ

What does Zapier cost in real use?

It depends on step count rather than automation count. The free plan with a hundred tasks covers experiments. A three action process triggered a hundred times a day is roughly nine thousand tasks a month, which sits in the professional plan with the slider set accordingly, meaning tens of dollars a month.

What exactly counts as a task?

Every action reaching an external application. Filters, paths, formatting, delays, and the built in tables and forms do not count. A call through Zapier MCP costs two tasks.

Zapier or n8n?

Zapier wins on ready integrations and simplicity of setup, so it suits non technical teams and short processes better. n8n bills per whole run rather than per step and can be self hosted, so it wins on long processes, high volume, and sensitive data.

Is the free plan enough for anything useful?

For one simple connection yes, copying a form submission into a spreadsheet for instance. The two step limit rules out anything needing a condition or a second action, so real processes usually force a paid plan.

Can I connect Zapier to an AI assistant?

Yes, through Zapier MCP, which exposes the platform's integrations to models supporting that protocol. The assistant can then perform actions in your applications, with every call costing two tasks, so limiting the set of exposed tools pays off.

Current pricing sits on zapier.com, and the documentation in Zapier help.