Zapier vs Make vs n8n: Task Meters, Credit Iterator Tax, and Self-Host TCO for iPaaS

The meter is the product

Procurement still pastes “starts at $20” into a spreadsheet and calls that TCO. That cell is the on-ramp, not the operating cost. The three vendors sell three different things.

• Zapier task: a successful action step. Triggers, Filters, Paths, Formatter, Delay, Looping, Digest, Storage, Tables, and Forms do not consume tasks. Every CRM write, Slack post, Sheet row, HTTP call, and most AI steps do. Zapier MCP tool calls draw from the same pool at 2 tasks each.
• Make credit: a module execution (the 2025 rename of “operation”). Webhook receipt is 1 credit. Each Iterator child bundle re-runs every downstream module. AI and code steps cost more than 1.
• n8n execution: one start-to-finish workflow run. A 3-node flow and a 40-node flow with branches, Code nodes, and four destinations still count as 1.

We modeled a 16-location group (Toast or Square for Restaurants as the source of truth, 7shifts or Deputy for labor, a warehouse for nightly close). The pattern is mechanical. If finance signs Zapier Professional at 750 tasks because “we only have eight Zaps,” the first 4-step order-exception Zap will empty the month.

Pricing, rate limits, and feature lock matrix

Figures are public list prices as of August 2026, annual billing unless noted. USD for Zapier and Make. EUR for n8n Cloud (vendor list). Cross-check live pages before a purchase order. Credit packs and Enterprise quotes move.

Zapier: 750 tasks is a two-Zap plan

The Professional on-ramp is a counting trick

Zapier’s 2026 self-serve ladder is Free / Professional / Team, plus Enterprise via sales. You pick a plan level and a task tier. Professional at 750 tasks is $19.99 on annual, $29.99 on monthly. That is the slide-deck number. It is also the number that fails first.

A production Zap for a restaurant exception desk is rarely two steps:

1. Trigger: POS order closed (instant, does not bill).
2. Filter: void or comp over $50 (does not bill).
3. Action: write a row to the warehouse or Sheets (1 task).
4. Action: notify Slack with the GM and the regional manager (1 task).
5. Action: patch the ticket in the support desk (1 task).
6. Action: append a labor flag in 7shifts or Deputy (1 task).

Four billed actions × 200 events = 800 tasks. Professional 750 is gone on a single Zap. The next published Pro tier is 1,500 at $39 or 2,000 at $49. Teams cannot even start below 2,000 tasks ($69).

Triggers, Filters, Paths, Formatter, Delay, and Looping are free. That sounds generous until the Looping app hits 500 items and one loop per Zap. Nested line items need a Code step to flatten first. Code on Pro includes 30 seconds. Runtime beyond that rounds up in 30-second blocks at 1 task each. Enterprise Code includes 2 minutes.

type ZapierPlan = "free" | "pro" | "team" | "enterprise";

interface TaskBudget {
  plan: ZapierPlan;
  includedTasks: number;
  pollingMinutes: 15 | 2 | 1;
  codeSecondsIncluded: 1 | 30 | 120;
  loopCeiling: 500;
  pptMultiplier: 1.25 | 2.5 | 0;
  pauseAt: number;
}

export function zapierBudget(plan: ZapierPlan, monthlyTasks: number, annual = true): TaskBudget {
  const ppt: 1.25 | 2.5 | 0 = plan === "free" ? 0 : annual ? 1.25 : 2.5;
  const included =
    plan === "free" ? 100 :
    monthlyTasks <= 750 ? 750 :
    monthlyTasks;
  return {
    plan,
    includedTasks: included,
    pollingMinutes: plan === "free" ? 15 : plan === "pro" ? 2 : 1,
    codeSecondsIncluded: plan === "enterprise" ? 120 : plan === "free" ? 1 : 30,
    loopCeiling: 500,
    pptMultiplier: ppt,
    pauseAt: included * 3,
  };
}

export function billableZapTasks(opts: {
  actionSteps: number;
  mcpToolCalls: number;
  codeExtraThirtySecondBlocks: number;
}): number {
  return opts.actionSteps + opts.mcpToolCalls * 2 + opts.codeExtraThirtySecondBlocks;
}

Instant is not unlimited

Polling on Free is every 15 minutes. Professional is 2 minutes. Team and Enterprise are 1 minute. For POS and KDS, polling is the wrong primitive. Use instant webhooks.

Official webhook ceilings (429 when exceeded):

• 30 requests per second per webhook
• 20,000 requests every 5 minutes per user across instant triggers
• 1,000 requests every 5 minutes per Zap on legacy webhook URLs that omit a user id

During floods Zapier may still return HTTP 200 and delay processing by several minutes. A Friday dinner rush that fans 16 stores into one Catch Hook will look healthy in the sender log and late in Slack. Held runs (task cap) are not lost, but they sit until you buy more tasks or wait for the monthly reset.

Pay-per-task is the other silent invoice. Enable it and overage bills at 1.25× (annual) or 2.5× (monthly) the base task rate, then stops at 3× the subscribed tier. Disable it and Zaps hold. Neither path is “unlimited headroom.”

Make: the canvas is excellent, the Iterator is a multiplier

Credits replaced operations. The math did not get kinder.

Make (formerly Integromat) moved from “operations” to credits on 27 August 2025. A standard module run is still about 1 credit. AI modules and code at 2 credits per second are not. Paid plans share a 10,000-credit base:

• Core: $12/month annual, unlimited active scenarios, 1-minute scheduling, Make API, files around 100 MB
• Pro: ~$21/month annual, priority execution, custom variables, full-text log search, files around 250 MB
• Teams: ~$38/month annual, roles, shared templates, files around 500 MB
• Enterprise: custom SSO, audit, SLA

You then slide the credit pack: 10k, 20k, 40k, 80k, 150k, 300k, and up. Core at 10k is a genuine bargain for filtered, non-iterated flows. It is not a bargain for POS tickets.

A closed ticket with 8 line items, iterated into inventory and a warehouse write, is not 1 credit.

Webhook (1)
+ Router (1)
+ Iterator over 8 lines (1)
+ HTTP PATCH inventory × 8
+ HTTP POST warehouse line × 8
+ Array Aggregator (1)
+ Slack summary (1)
= 1 + 1 + 1 + 8 + 8 + 1 + 1 = 21 credits per ticket

At 38,400 tickets per month that scenario alone is 806,400 credits. Core’s 10,000 credits last about 9 hours of lunch service at one busy store, not a 16-unit group. Batch with an Aggregator and a bulk endpoint, and the same job can drop to a handful of credits per ticket. The product rewards people who think in bundles. It punishes people who translate Zapier steps 1:1 onto the canvas.

{
  "event": "order.closed",
  "locationId": "loc_16_osaka_namba",
  "ticketId": "tkt_9f2a",
  "lineItems": [
    { "sku": "RAMEN-MISO", "qty": 2, "void": false },
    { "sku": "GYOZA", "qty": 1, "void": true, "voidAmount": 6.8 }
  ],
  "make": {
    "creditsIfIterated": 21,
    "creditsIfAggregatedBulkWrite": 5,
    "planAt10k": "Core will halt this store before close"
  }
}

Concurrency, files, and the log you cannot search

Free is 2 active scenarios. That is an evaluation SKU. Production needs Core. Debugging a failed Iterator at volume needs Pro’s full-text execution search and priority execution. Teams is the first plan that looks like a shared ops function rather than a personal canvas.

Data transfer and file-size ceilings are the second meter. Core’s ~100 MB file cap and the plan’s transfer bucket show up when you move camera stills from a health-inspection app or nightly CSV dumps from a legacy POS. The scenario does not fail loudly on “credits.” It fails on a module error that looks like the destination API.

n8n: one execution is the gift. Governance is the invoice.

Cloud is still metered. Community is still not “free DevOps.”

n8n Cloud (hosted in Frankfurt) as of August 2026:

An execution is the whole graph. That is why a 10-step, 10,000-run month is 10,000 on n8n and 100,000 on Zapier. Starter at 2,500 executions is still small for POS. A 5-minute cron is about 8,600 executions per month before any webhook. Count scheduled jobs first.

Self-hosted Community Edition has no vendor execution cap. Queue mode (Redis + workers) is included. What Community does not include: SAML/LDAP SSO, Git environments, external secret stores, log streaming, multi-main HA, external binary storage, project RBAC at Business depth. Those are Business or Enterprise features, including when you run the binary on your own iron.

The license is the other constraint. n8n is fair-code under the Sustainable Use License. Internal restaurant or SaaS ops: allowed. Embedding n8n so your customers log in and build workflows as the product you sell: not allowed without a commercial agreement. Reddit threads titled as license warnings are not folklore. Legal should read the SUL before a customer-facing automation portal ships.

# Minimal production shape. Community can run queue mode.
# SSO, Git, multi-main still need a Business/Enterprise key.
version: "3.8"
services:
  n8n-main:
    image: docker.n8n.io/n8nio/n8n:1.107.4
    environment:
      EXECUTIONS_MODE: queue
      QUEUE_BULL_REDIS_HOST: redis
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
      N8N_METRICS: "true"
      WEBHOOK_URL: https://hooks.ops.example.com/
    ports: ["5678:5678"]
  n8n-worker:
    image: docker.n8n.io/n8nio/n8n:1.107.4
    command: worker
    environment:
      EXECUTIONS_MODE: queue
      QUEUE_BULL_REDIS_HOST: redis
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
    deploy:
      replicas: 3
  redis:
    image: redis:7-alpine
  postgres:
    image: postgres:16-alpine

What self-host actually costs

Community n8n on a Hetzner CX22 (2 vCPU, 4 GB) at about $6/month is a real Reddit setup, and it will run a few dozen light workflows. A 16-unit POS webhook fan-in wants more:

Price labor. A $6 box with no snapshots is not cheaper than Make Core if a missed close-of-day costs one region manager a Saturday. Community users on the n8n forum who left Zapier at $20–$49 report $320–$500/year saved. Users who left a $150–$200 Zapier-plus-Make stack report payback in one quarter. Users who needed SSO still bought Business.

TCO by volume (annual-equivalent monthly)

Align the workflow, then the meter. The model below uses 4 billed Zapier actions, 4 Make credits if aggregated vs 21 if iterated, and 1 n8n execution per event. Annual Zapier/Make list. n8n Cloud in EUR converted at ~$1.10 for the cash column.

Three-year cash for the 38,400-event restaurant case, feature set frozen, no list-price increase: Zapier Professional 200k ≈ $27,700. Make aggregated at ~$120/month ≈ $4,300. n8n Community at $60/month fully loaded infra ≈ $2,160, plus capitalized build time. Cloud n8n Business at €667 is in Zapier’s neighborhood and only wins if you need Git/SSO without Zapier’s task multiplier.

WITH assumptions AS (
  SELECT
    16::int AS locations,
    80.0::numeric AS tickets_per_location_day,
    30::int AS days,
    4::int AS zapier_action_steps,
    4::int AS make_credits_aggregated,
    21::int AS make_credits_iterated
),
events AS (
  SELECT
    locations * tickets_per_location_day * days AS monthly_events,
    locations * tickets_per_location_day * days * zapier_action_steps AS zapier_tasks,
    locations * tickets_per_location_day * days * make_credits_aggregated AS make_agg,
    locations * tickets_per_location_day * days * make_credits_iterated AS make_iter
  FROM assumptions
)
SELECT
  monthly_events,
  zapier_tasks,
  make_agg,
  make_iter,
  monthly_events AS n8n_executions,
  CASE
    WHEN zapier_tasks > 750 THEN 'Zapier Pro 750 will hold runs'
    ELSE 'Zapier Pro 750 may survive'
  END AS zapier_750_verdict,
  CASE
    WHEN make_iter > 10000 THEN 'Make Core 10k dies if you iterate line items'
    ELSE 'Make Core may survive'
  END AS make_core_verdict
FROM events;

Multi-unit restaurant pattern (Vecta Solve field)

A 16-location group usually needs four live flows, not one:

1. Order-exception webhook (voids, comps, no-sales) to Slack + incident sheet.
2. Nightly close from POS to warehouse (BigQuery, Snowflake, or Postgres).
3. 86’d item from inventory to KDS / menu board.
4. Labor variance from POS sales to 7shifts or Deputy.

Keep (1) and (3) near-real-time. Those are webhook-shaped. Put (2) on a warehouse job or n8n cron so Make credits and Zapier tasks are not eaten by every line item of every ticket. Native POS automations (Toast, Square) should handle printer/KDS routing. iPaaS that sits in the ticket path adds 429 risk at dinner.

query FailedCloses($since: ISO8601DateTime!, $cursor: String) {
  locations {
    id
    tickets(closedAt_gte: $since, status: FAILED, first: 100, after: $cursor) {
      pageInfo { hasNextPage endCursor }
      edges {
        node {
          id
          locationId
          voidAmount
          lineItemCount
        }
      }
    }
  }
}

Page at 100, filter server-side, and do not pull lineItems { ... } until an exception ticket needs them. Full-ticket GraphQL on every close is how a “simple sync” becomes 21 Make credits.

What Reddit and X say that the grid omits

Community anger is about invoices and 2 a.m. queues, not canvas aesthetics.

• r/n8n, “is it worth switching”: operators paying $150–$200/month on Zapier plus Make ask whether a VPS replaces both. The stable answer is yes for internal workflows if someone already speaks Docker. It is no if the team is non-technical and the workflows are two-step CRM updates.
• n8n forum, one-year self-host recap: Hetzner CX22 at $6, Docker, Nginx, Cloudflare tunnel. Prior Zapier Starter/Professional at $20–$49, occasional $49 months. Year-one savings $320–$500. Unlimited executions. The same thread tells non-technical owners to stay on Zapier.
• Make community / YouTube operator lore: 10 modules × 10 bundles = 100 operations “before you know it,” then a $5 overage that becomes a habit. Iterator-plus-Aggregator literacy is the actual skill Make sells.
• Zapier Community: Looping runs in parallel, hits destination 429s, and the 500-item ceiling is a hard stop. Code timeouts at 30 seconds on Pro/Team push people to split Zaps, which doubles task burn.
• License threads: agencies that wrap Community n8n as a client portal get reminded the SUL does not allow that. The cheap VPS is not a white-label iPaaS license.

X commentary tracks the same fork. A $5–$15 VPS beating a $500 Zapier plan is true for execution volume. It is false as a staffed, SSO-gated, audited platform. Those features are n8n Business/Enterprise or Zapier Team/Enterprise.

API, polling, and the dinner-rush 429

The monthly meter and the burst meter are different clocks.

Zapier. Instant triggers share 20,000 requests / 5 minutes / user. Catch Hooks add 30/s. Legacy URLs add 1,000 / 5 minutes / Zap. Flood protection (paid) can freeze a runaway Zap so a retry loop does not drain the month. Autoreplay is Professional and above. Held runs need a human.

Make. Credits are the monthly clock. Concurrency and data transfer are the burst clock. An Iterator that fans 200 HTTP modules at once will 429 the destination even if credits remain. Sleep / rate-limit modules exist because operators learned this in production.

n8n. Cloud concurrent caps are the burst clock (5 on Starter). Self-host burst is worker count × concurrency per worker. Without a queue, one process executes in-process and latency spikes under webhook storms. Put a webhook processor and workers in front of POS traffic.

export async function postWith429Budget(
  url: string,
  body: unknown,
  opts: { perSecond: number; maxAttempts?: number }
) {
  const gap = Math.ceil(1000 / opts.perSecond);
  let attempt = 0;
  const max = opts.maxAttempts ?? 6;
  while (true) {
    const res = await fetch(url, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify(body),
    });
    if (res.status !== 429) return res;
    const retryAfter = Number(res.headers.get("retry-after") ?? "0") * 1000;
    const wait = Math.max(gap * 2 ** attempt, retryAfter);
    await new Promise((r) => setTimeout(r, wait));
    attempt += 1;
    if (attempt > max) throw new Error("destination 429 persisted");
  }
}

Rule of placement: human-facing, low-volume, many-app glue stays on Zapier. Shape-heavy, mid-volume data stays on Make with aggregation. High-volume, PII-sensitive, or custom-node work moves to n8n (Cloud Pro if you want no Linux; Community if you will own the box). See Toast vs Square vs Deputy for why the POS itself should own ticket firing, and ClickUp vs monday.com for why in-app automation packs should not carry the warehouse load.

How to choose without a slogan

Zapier is the rational buy when

• Non-technical owners must ship this week across long-tail SaaS (9,000 apps)
• Volume stays under a few thousand tasks, not events
• You will pay Team ($69+) as soon as a second builder and SSO show up
• Polling at 1–2 minutes is acceptable, or the apps offer instant triggers you will actually use

Make is the rational buy when

• Payloads are nested (line items, modifiers, roster arrays)
• Someone on the team can think in Iterators and Aggregators
• Monthly credits stay in the 10k–150k packs after aggregation
• You want a visual debugger without running Postgres
• Test Make Core with 10,000 free credits and a 1-month trial

n8n is the rational buy when

• Events per month climb past Make packs or Zapier 50k-task tiers
• PII, guest data, or card-adjacent metadata should not transit a US SaaS by default
• You can staff Docker, backups, and a pinned image, or you will pay Cloud Pro/Business
• You need Code/Python, custom nodes, or Git-reviewed workflows

None of the three on the cheap SKU when

• SAML, audit log streaming, and a contractual SLA are procurement gates (Zapier Enterprise, Make Enterprise, n8n Business/Enterprise)
• You are building a customer-facing automation product on Community n8n (SUL)
• The workflow sits in the hot path of ticket printing or KDS (keep that inside the POS)

Procurement and IT FAQ

Q1. Does a Zapier trigger count as a task?

No. Successful action steps count. Filters, Paths, Formatter, Delay, Looping, Tables, and Forms do not. Actions inside a loop do. MCP tool calls count as 2.

Q2. Is Make Core 10,000 credits per user?

No. It is an organization pack. Every scenario, every Iterator child, every teammate draws from the same 10,000 unless you buy a larger pack.

Q3. Is self-hosted n8n actually unlimited?

Executions, yes, on Community. Concurrent throughput is a function of RAM, workers, and Redis. Governance (SSO, Git, HA multi-main) is not unlimited. It is licensed.

Q4. What happens when Zapier hits the task cap?

Held runs, or pay-per-task at 1.25× / 2.5× until 3× the tier. Held runs can be replayed after you add tasks. They are not a substitute for capacity planning.

Q5. Can we start on Zapier and migrate later?

Yes, and many teams do. Budget rewrite cost. Zapier Paths do not map 1:1 to Make Routers or n8n Switch nodes. Line-item loops must be redesigned or you will import the Iterator tax.

Q6. Where should guest PII live?

If a DPA, PCI-adjacent log, or regional residency clause exists, prefer n8n in your VPC or Make/n8n Cloud with an EU processing story. Do not put full PAN or raw card payloads on any of these tools.

Q7. Do annual plans change the meter?

Zapier annual discounts the dollar and the overage multiplier (1.25× vs 2.5×). The monthly task allowance still resets monthly on self-serve. Enterprise can buy an annual task limit for seasonal spikes. Make and n8n Cloud also discount annual; units still accrue per month (n8n Business sales will talk at 80% of annual quota).

Five checks before the business case leaves the building

1. List every live flow. For each, count events × billed units (Zapier actions, Make credits after Iterator math, n8n runs). Use a 14-day log, not a guess.
2. Separate webhook storms (POS, forms) from crons. A 5-minute cron is ~8,600 n8n executions before any customer traffic.
3. Date the SSO and audit requirement. Inside 12 months, model Zapier Team/Enterprise, Make Enterprise, or n8n Business on day one.
4. Assign an owner for credentials and retries. If that owner is “whoever built the Zap,” you do not have a platform. You have a personal account.
5. Price labor. A $6 VPS plus eight unpaid engineering hours is not a $6 platform.

A comparison sheet that only lists “from $20 / $12 / €20” is a sorted landing page.

Conclusion

Zapier versus Make versus n8n is decided by the counting rule, the burst ceiling, and who is on call. Zapier sells the widest connector catalog and the steepest per-step invoice, with Professional 750 as a funnel into $49, $129, and $489 task tiers, pay-per-task multipliers, a 500-item loop cap, and webhook 429s that show up during real service, not during demos. Make sells the best visual transformation canvas and a 10,000-credit on-ramp that remains cheap only if you aggregate instead of iterate. n8n sells execution-priced Cloud and a Community binary that can replace a mid-three-figure SaaS bill on a small VPS, at the price of Linux, a fair-code license, and governance features that live on €667 Business.

For a two-step CRM or Slack alert at a few hundred runs, buy Zapier Professional and watch the task report weekly. For nested tickets at tens of thousands of credits after aggregation, buy Make Core or Pro. For 16 stores firing POS webhooks all month, self-host n8n with queue mode, or pay n8n Cloud at a tier that actually covers the cron plus the webhooks. Approving Zapier at $19.99 because “automation should be simple” is how a restaurant group funds someone else’s usage-based growth plan.

Drop event volume, steps per event, and whether you will iterate line items into the SaaS comparison simulator. Add three rows under list price: unit definition, burst 429, and hours of ops labor. Those three rows are the scope of this review.