n8n vs Zapier vs Make: Three Workflows Priced at 1,000 to 100,000 Runs a Month

n8n vs Zapier vs Make comes down to the unit each one bills: Zapier charges a task for each action step that succeeds, Make a credit for each module run, trigger included, and n8n one execution per workflow run, however many steps it has. On list prices read November 2, 2026, billed yearly, our model puts a 7-step order pipeline at 10,000 runs a month at $435.00 on Zapier, $83.25 on Make and $50.00 on n8n Cloud. That n8n plan sits exactly at its 10,000-execution cap.

To get those numbers we wrote a small Node script on the three public pricing pages, read on publish day, and ran three illustrative workflows through it at 1,000, 10,000 and 100,000 runs a month. Make (formerly Integromat) had the lowest list price at 1,000 runs in all three workflows. n8n Cloud had the lowest for the order pipeline at 10,000 runs and for an hourly polling job from 10,000 new items up. Zapier did not have the lowest list price in any case the model tested. In short, Make costs least at low volume, n8n Cloud costs least once a workflow has many steps or loops at 10,000 runs a month, and Zapier earns its price through the time it saves non-technical builders, not through the bill. The script and its unedited output are at the end, so you can put in your own step counts.

Keplaris builds client automations on n8n, Make and custom Node.js, as part of our workflow automation and AI systems service. Weigh our verdict with that in mind. It is also why every vendor price below is a constant in the script, next to the page it came from and the date we read it.

n8n vs Zapier vs Make: the difference in short

The three tools bill different units, so their plan prices can't be compared until you count one workflow in each unit. The same order pipeline costs 7 Zapier tasks, 9 Make credits and 1 n8n execution per run. Here is the rest of the gap, read on each vendor's pages on 2026-11-02:

Sources: Zapier pricing, Zapier task usage, Zapier data privacy, Make pricing, Make operations, Make data zones, n8n pricing and n8n executions.

Taken pair by pair, the model gives three results:

• n8n vs Zapier. n8n Cloud's list price was below Zapier's in every case the model tested where n8n Cloud publishes a price, because Zapier bills each action and n8n bills the run. The order pipeline at 10,000 runs a month is $50.00 on n8n Cloud against $435.00 on Zapier, billed yearly.
• Make vs Zapier. Make's list price was below Zapier's in every case the model tested, from $12.00 against $49.00 for the lead sync at 1,000 runs to $937.50 against $1,999.00 for the order pipeline at 100,000. Zapier's offsets are that triggers, polls, filters and failed actions cost no tasks, and that it lists 9,000+ apps against Make's 3,500+.
• n8n vs Make. The result splits by workflow shape. Make was lower at 1,000 runs in all three workflows and for the lead sync at 10,000 runs ($34.13 against $50.00). n8n Cloud was lower for the order pipeline at 10,000 runs ($50.00 against $83.25) and for the hourly polling job from 10,000 new items ($20.00 against $22.31). At 100,000 runs n8n Cloud has no published price, and self-hosted Community at our $401.88 mid estimate sits below Make on the order pipeline ($937.50) but above it on the lead sync ($237.00).

On integrations, Zapier's pricing page says it connects "9,000+ apps", Make's says "3,500+ apps" and n8n's integrations page says "2,000+ integrations". n8n's template library lists 13,825 workflow templates; Zapier and Make each link a template library but print no count on the pages we read. All three can call an app's API over HTTP when there is no connector; on Zapier, Webhooks is a Professional feature. All of this was read November 2, 2026.

Zapier tasks vs Make credits vs n8n executions: how each is counted

Zapier counts action steps that succeed, Make counts module runs per bundle of data, and n8n counts whole runs. The difference is small on a 3-step workflow and large on one with loops, because Zapier and Make bill each pass through a loop and n8n doesn't.

A Zapier task is one action step that completes successfully. Zapier's help center lists what doesn't count: "All trigger steps", "Any Filter or Paths step", "All action steps that error or halt", and the Formatter, Delay, Looping, Sub-Zap, Digest and Storage apps. Its own example: a Zap that saves a Gmail attachment to Dropbox and messages Slack "uses two tasks. If your Zap runs ten times, it will use 20 tasks."

A Make credit is one module run on one bundle of data, and the trigger costs one on every check. Make's credits page says "By default, 1 operation equals 1 credit", and its operations page explains the multiplier: a module runs once for each bundle it receives, so "Since each bundle requires a module run, bundles in earlier modules have a multiplying effect on the operations in the rest of the scenario." The trigger is the exception. In Make Academy's credit lesson, "The trigger module will always perform one operation and consume one credit regardless of how many emails were sent", even when the answer is zero. Make bills the trigger on every check, so an hourly scenario spends at least 720 credits a month even if it finds nothing.

Make switched its billing unit from operations to credits in 2025. Its pricing page says "As of August 27, credits are the billing unit in Make", and its release note says existing operations converted "at a 1:1 ratio", with "1 operation still uses 1 credit" for non-AI features. Pages that still say "operations" are describing the same count under the old name. Of the ten top-ranking results we examined on November 2, 2026, we read eight (one returned HTTP 410 and one returned 403). One of the eight, automationatlas.io's comparison, says it was "Updated with current data as of March 2026" and still prices Make in operations.

n8n's pricing page puts its rule in one sentence: "An execution is a single run of your entire workflow. It doesn't matter how many steps are in the workflow or how much data it processes." Its docs add what doesn't count: manual runs, sub-workflow runs ("only the parent (top-level) execution counts"), error-workflow runs and polls that return no data.

Here is our order pipeline (W2 in the model) counted step by step. "7-step" means the seven steps after the webhook trigger: lookup, branch, two actions, Slack summary, loop and inventory update.

Seven steps and 7 tasks is a coincidence of the 3 line items: the task count follows the line items, not the step count. Order matters on Zapier and Make: a step placed after a loop runs once per item, so the Slack summary goes before it. We count Make's Iterator as 1 credit a run because it receives one bundle (the array) per run, which is how Make's operations page counts modules. Make lists "iterate a row of data" among actions that use credits but prints no Iterator example on the pages we read, so that count is our reading, labelled as an assumption in the script.

Batches show the gap most clearly. One run that pushes 500 rows through two actions costs about 1,000 Zapier tasks, about 1,001 Make credits and 1 n8n execution. On Zapier each new item starts its own Zap run; Zapier's polling example uses "two tasks" for "two new leads". On Make the trigger costs 1 credit and each of the 500 bundles costs 2.

What happens when you run out of tasks, credits or executions

Zapier keeps running at a higher per-task rate until usage reaches 3 times your plan's tasks, Make stops scenarios until you add credits, and n8n Cloud's Starter and Pro plans are capped with no overage. The plan data on Zapier's pricing page bills extra tasks at about 1.25 times the plan's own per-task price on both annual and monthly plans: 0.73 cents a task on the $289 annual 50,000-task tier and 1.09 cents on the $433.50 monthly one.

• Zapier. Pay-per-task is on by default for accounts that joined after January 2024. Neither the pricing page's text nor the pay-per-task help article prints a multiplier. The pricing page says pay-per-task "is charged at a higher per-task rate than your base subscription tasks", and the help article says the rate "depends on your plan and billing cycle type" and points to your billing settings. The per-task rates sit in the plan data the pricing page embeds, where each plan's maximum pay-per-task charge equals that rate on twice the plan's tasks, which is the 3 times limit. Zapier's own task explainer (updated June 2026) gives a different monthly figure: "For annual plans, extra tasks are billed at 1.25x your plan's normal task cost. For monthly plans, the rate is 2.5x." The two Zapier sources agree on annual plans and disagree on monthly ones, so the model uses the pricing page's rates. The cap is in the help article: Zaps "will stop running if your account reaches the maximum pay-per-task usage amount. This is set at 3 times your plan's task limit". After that, new runs are held until the cycle resets. n8n's own Zapier comparison gives the overage as "1.25x", which matches the rates in Zapier's plan data.
• Make. The pricing page FAQ: "Your scenarios won't continue to run, until credits are added again. Incoming webhooks will be queued up to the amount of webhook queue storage you have available". The queue allowance is 667 webhooks per 10,000 credits, up to 10,000. Make's extra credits page sells credits in units of 1,000 at "a 25% additional cost", and its example works it out: on a $9 plan with 10,000 credits, "1,000 extra credits, it costs $1.125". Auto-purchase buys 10,000 at a time and is limited "to the number of credits in your subscription"; the page states no such limit for credits bought by hand. Extra credits expire at the end of the billing cycle, and on Core billed yearly "any extra credits you purchase will also expire at each monthly reset".
• n8n. The pricing page's overage tooltip reads "Starter and Pro are capped and have no overages." It does not say whether runs past the cap stop or queue. n8n's docs pages we read don't either, and its community forum disagrees: one user reported in July 2025 that after the monthly limit "All workflows instantly break", while a community member with the forum's "Top Supporter" title, not n8n staff, told another user in November 2025 that new executions pause after a small buffer. Self-hosted Business is different: "Your workflows keep running", and overage costs "€4,000 / $4,800 per 300k" extra executions.

The n8n Cloud cliff above 50,000 executions

n8n Cloud's published plans stop at 50,000 executions a month; past that you need a quote or your own server. The Pro plan has two sizes on the pricing page's selector, 10,000 and 50,000 executions, and its third option is "Custom plan". The next published plan, Business, is "currently only available for self-hosted n8n".

Euro amounts are converted at the European Central Bank reference rate in its file dated October 30, 2026 (1 EUR = 1.1172 USD), the latest on the morning of November 2. n8n's USD list is not a currency conversion of its euro list: the 40,000-execution Business plan is $800 in USD and 666.67 EUR, about $744.80 at that rate. The model uses the USD list, to compare like with like.

The cliff is closer than the Pro plan's name suggests. Our order pipeline at 10,000 runs fills Pro's 10,000 executions exactly, so a busy month needs the 50,000 size at $120 a month. At 100,000 runs there is no Cloud price to put in the table.

Zapier vs Make vs n8n pricing at 1,000, 10,000 and 100,000 runs a month

On list prices read November 2, 2026, billed yearly, Make cost least at 1,000 runs in all three workflows and for the lead sync at every volume. n8n Cloud cost least for the order pipeline at 10,000 runs and for the polling job from 10,000 items up. Zapier cost most of the three services in every table cell below.

For the 7-step order pipeline at 10,000 runs a month, the model gives $435.00 on Zapier, $83.25 on Make and $50.00 on n8n Cloud.

The workflows are assumptions, not client data: we chose them to show where the units diverge.

The model picks each vendor's plan by a fixed rule. All prices are USD a month, billed yearly, before tax.

Lead sync, 3 steps after the trigger: USD a month, billed yearly

Order pipeline, 7 steps with a branch and a loop: USD a month, billed yearly

Hourly polling job, 2 steps per new item: USD a month, billed yearly

Runs here means new items found in the month.

The polling job is where the units split furthest. Zapier bills each item and not the polls, Make bills the polls and each item, and n8n bills at most one execution per poll, so 100,000 items still fit in Starter's 2,500 executions. That holds only if each run finishes inside Starter's 5-minute maximum execution time, which at 100,000 items a month means about 139 items a poll (100,000 / 720). Polling every 5 minutes instead hands the 10,000-item case back to Make: at 1,000 and 10,000 new items it costs $13.50 and $32.81 on Make against $20.00 and $50.00 on n8n Cloud with a polling trigger, because more checks find new data and each of those is an n8n execution.

Billed monthly instead, the order pipeline at 10,000 runs costs $651.50 on Zapier, $112.16 on Make and $60.00 on n8n Cloud. Two sensitivities move Make and Zapier together: with 1 line item per order, the order pipeline at 10,000 runs costs $289.00 on Zapier and $72.00 on Make, and with 10 line items it costs $737.00 and $139.75. n8n stays at $50.00 in both, because the run count doesn't change.

Traced example: the order pipeline at 10,000 runs

• Zapier: 10,000 runs at 7 tasks is 70,000 tasks. The 50,000-task tier costs $289 a month billed yearly, and 20,000 extra tasks at that tier's pay-per-task rate of 0.73 cents add $146.00, so $435.00. The 100,000-task tier costs $489.00, so pay-per-task beat the next tier by $54.00. Billed monthly, the same need costs $651.50: the $433.50 monthly tier plus 20,000 tasks at 1.09 cents.
• Make: 10,000 runs at 9 credits is 90,000 credits. Core's 80,000-credit tier costs $72 billed yearly on the US list, and 10,000 extra credits at ($72 / 80,000) x 1.25 add $11.25, so $83.25, against $129.00 for the 150,000 tier.
• n8n Cloud: 10,000 runs is 10,000 executions, exactly Pro's smaller size at $50.00. One busy month pushes you to the 50,000 size at $120.00.

What this model does not prove

• List prices only. No discounts, no non-profit or Start-up plans, and no negotiated Enterprise terms on any of the three.
• The workflows are illustrative, not metered client runs, and step counts change with how a person builds the workflow.
• Volume is held flat for the month, and runs are spread evenly.
• Left out: AI token bills, build time, the cost of moving workflows between tools, and taxes.
• The server line is not load-tested. We have not run 100,000 executions a month on the droplet we priced.
• Make's prices are its US list, read from the price table its pricing page loads, and Make quotes different USD lists in other countries.
• Make extra credits are capped in the model at the tier's own credit count, which is Make's auto-purchase limit. Bought by hand without that cap, the order pipeline at 100,000 runs would cost $829.50 on Core, not $937.50.
• Zapier's overage follows its pricing page's plan data, about 1.25 times the plan's per-task price on both billing cycles. If the blog's 2.5 times applied to a monthly plan, the order pipeline at 10,000 runs would move to the 100,000-task monthly tier at $733.50.
• n8n's prices are the USD list its page showed us. The euro list differs, and the conversion uses one day's rate.
• Make's Iterator count is our reading of its operations rule. If it bills per row, the order pipeline rises to 11 credits a run and the Make column changes.

Is self-hosted n8n free and open source? Costs and the licence

Self-hosted n8n has no licence fee and no execution cap, and its licence is source-available, not open source. At our mid estimate the server and upkeep come to about $401.88 a month: $28.80 for a DigitalOcean droplet with backups and $373.08 for an assumed 4 hours of upkeep at $93.27 an hour. n8n's compare editions page says the free Community edition "includes almost the complete feature set of n8n", and lists what it lacks: SSO, projects, environments, Git version control, external secrets, log streaming and sharing, among others.

The hourly rate is the one our build vs buy software guide uses. It starts from the $194,000 a year that our SaaS MVP cost guide gets by grossing up the BLS median developer wage: "Divided by 2,080 paid hours, that is $93.27 an hour, the rate our script uses." The build vs buy post also says that self-hosting open-source software means no license fee, but "you carry the hosting, upgrades and on-call, so for cost purposes it sits close to building". n8n's hosting docs give a concrete upgrade example: "npm installation is deprecated from n8n 3.0." We'll cover running n8n in production in a separate post.

So self-hosting pays off at volume, not at the start. At 1,000 runs a month, $401.88 is more than any of the three managed services in the model. For the order pipeline at 100,000 runs, it is below Make's $937.50 and Zapier's $1,999.00. For the lead sync at 100,000 runs, Make's $237.00 sits between our low and mid estimates. If you need SSO, Git or environments on your own server, self-hosted Business adds its licence: $1,201.88 a month in total at 10,000 executions (the 40,000 plan) and $2,127.88 at 100,000, both at mid upkeep.

The licence is n8n's Sustainable Use License, which lets you self-host but limits use. n8n's community licence page puts it plainly: "Although n8n's source code is available under the Sustainable Use License, according to the Open Source Initiative (OSI), open source licenses can't include limitations on use, so we do not call ourselves open source." The licence allows use "only for your own internal business purposes or for non-commercial or personal use". n8n's licence FAQ spells out what that means for client work:

• Allowed: "Build automations for your clients on your instance, as long as your clients do not have the possibility to create or edit them", "Charge your customers for workflow creation, setup, and maintenance services", and "Use n8n behind the scenes in your own product, where users can use and trigger the automations you built".
• Not allowed: "Host n8n as a service and allow your clients to build workflows", "Allow external end users to build or configure their own workflows through your product, whether via a custom UI, our API, MCP, or an AI agent acting on the user's behalf", and "White-label n8n by removing our branding and offering n8n as is."

The FAQ's own test is "who controls the workflow logic". If your customers will design their own automations inside your product, n8n points you to the n8n Enterprise License.

Error handling and retries

All three retry failed work, but they differ on what the retry costs. Zapier doesn't bill failed actions, but a full replay bills the steps that succeeded the first time again. Make's and n8n's pages we read don't say whether a retry or a re-run is billed again.

Sources: Zapier replay, Zapier error handling, Make incomplete executions, n8n node settings and n8n error workflows, read 2026-11-02.

One Zapier catch: once you add a custom error handler to a Zap, "autoreplay for the Zap will turn off to enable error handling." And on all three, a retry re-sends work to the receiving system, which may already have done it. That system has to treat duplicates as normal; as our webhook idempotency guide puts it, "Retries and duplicates are normal operation, not a bug to report."

n8n vs Zapier vs Make for AI agents: how AI steps are billed

On Zapier, an AI step comes out of your task pool. On Make, an AI step costs credits, and your own provider key moves the token bill to that provider. On n8n, the model call sits inside the one execution, and the tokens go to whoever supplies the model. For AI agents and other AI-heavy workflows, the billing gap is the same as for any step: Zapier and Make bill each AI step, n8n bills the run, and the model's tokens are a separate bill unless the vendor's own AI steps or credits cover them.

• Zapier. Its task usage rates page prices AI by Zapier per step by model tier: standard models 1 task, your own model 1 task, advanced models 3 tasks and premium models 5 tasks, with each tool call billed separately at its tier's rate (standard models don't support tool calls). Zapier's pricing page adds: "One MCP tool call uses two tasks." Zapier Agents don't use tasks at all: they draw on a separate quota of activities, 400 a month free or 1,500 on Agents Pro at $33.33 a month billed yearly.
• Make. Its credits page splits three cases. Make's AI Provider bills credits "based on tokens and operations". With your own OpenAI or Anthropic connection, "credits are based on operations. You pay your provider directly for tokens." Make's pricing page lists its Code app at "2 credits per 1 sec of code execution time".
• n8n. An AI Agent node is a step like any other, so it adds no executions. On Cloud Starter and Pro, Gateway credits pay for model calls without your own key, and n8n "bills usage per request" from a prepaid balance. Assistant credits are a different thing: they "only pay for n8n Assistant", the builder's helper, not the models your workflows call. Self-hosted, you bring your own key.

Whether a step should be a fixed workflow or an agent at all is a separate question; our guide to AI agents in SaaS argues that "most successful 'AI agent' features in SaaS products are workflows".

Hidden costs of Zapier, Make and n8n

Beyond the per-unit price, each tool has costs that show up after you build: Zapier's SSO tier and monthly premium, Make's country price lists and per-credit allowances, and n8n Cloud's run limits. The cap, overage and self-hosting costs are in the sections above.

Zapier

• Monthly billing costs about 1.5 times the yearly price, and the pay-per-task rate is about 1.5 times higher on monthly plans too, because it tracks the plan's own rate.
• SAML SSO needs Team, which costs $599.00 a month for our order pipeline at 10,000 runs against $435.00 on Professional.

Make

• The trigger bills on empty checks: polling every 5 minutes is 8,640 credits a month before any work, against 720 for hourly.
• The USD price list depends on your country. In our reads, the same Core 10,000-credit plan was $12 a month billed yearly on the US list and $9 on the list served to our location.
• Allowances scale with credits: 5 GB of data transfer and 667 queued webhooks per 10,000 credits.

n8n

• Starter limits you to 5 concurrent executions and 5-minute runs, with 7 days of execution logs; Pro gives 20 or 50 concurrent, 40-minute runs and 30 days.

Which one to choose: n8n, Zapier or Make

Choose on how your workflows are shaped and who builds them. The model shows no price win for Zapier in the cases tested, so pick Zapier for the time it saves the people building and fixing workflows, not for the bill.

Run the cost model yourself

Save the script as cost-model.mjs and run node cost-model.mjs. It needs Node 18 or later and nothing else: no npm install, no network. Each vendor price is a constant at the top with its page and read date, and each workflow, server and upkeep figure is a labelled assumption. Change the step counts and volumes to your own and re-run.

How we read the prices, in plain words. Zapier's tiers and pay-per-task rates come from the plan data its pricing page embeds, and the tier prices we compared with the page's slider matched it. n8n's page showed USD prices in our Chrome window, the same with a US and a German browser locale, while the HTML its server sends before scripts run shows euros; the script uses the USD list and prints the euro list beside it. Make's pricing page loads its price table from an API and blocks scripted fetches, and Make quotes different USD prices by country. We opened make.com/en/pricing in a normal Chrome window on November 2, 2026, then read the table the page requests with a US country code (it reported the "us" price variant). The plan cards Chrome showed us matched the list served to our own location, which confirmed which plan is Core, Pro and Teams. Check the page from your own location, because the list it shows you may differ.

Run metadata: Node v24.20.0, Apple M1 Max, macOS 27.0.1, run twice on 2026-11-02 with identical output.

// cost-model.mjs: what the same three workflows cost on Zapier, Make and n8n at 1,000 to 100,000 runs a month.
// Node 18+, no dependencies, no network. Run: node cost-model.mjs
// Every vendor price below was read on the vendor's public page on 2026-11-02 (URL beside each).
// Workflow step counts, server size and upkeep hours are ASSUMPTIONS, labelled below. Change any constant and re-run.
// List prices only, USD a month, before tax. A month is 30 days.

const READ = "2026-11-02";

// ---- Zapier ----
// https://zapier.com/pricing (read 2026-11-02). Prices are the plan data the page embeds: "amount" in cents
// per year (annual) or per month (monthly), and the pay-per-task rate in cents per extra task, the last pair
// of "metered_pricing_tiers". Each plan's "max_metering_charge" equals that rate x 2 x the plan's tasks,
// which matches the 3x cap below. These are all 18 paid Professional tiers in that data.
// "Triggers don't count toward your task limit." "If the action isn't successfully completed,
// it doesn't count against your task limit."
// https://help.zapier.com/hc/en-us/articles/8496196837261 (read 2026-11-02): not counted are "All trigger
// steps", "Any Filter or Paths step", "All action steps that error or halt", Formatter, Delay, Looping,
// Sub-Zap, Digest, Storage, Tables and Forms.
// Professional: [tasks a month, $ a month billed yearly, $ a month billed monthly,
//                pay-per-task cents a task billed yearly, pay-per-task cents a task billed monthly]
const ZAPIER_PRO = [
  [750, 19.99, 29.99, 3.34, 5], [1_500, 39, 58.5, 3.25, 4.88], [2_000, 49, 73.5, 3.07, 4.6],
  [5_000, 89, 133.5, 2.23, 3.34], [10_000, 129, 193.5, 1.62, 2.42], [20_000, 189, 283.5, 1.19, 1.78],
  [50_000, 289, 433.5, 0.73, 1.09], [100_000, 489, 733.5, 0.62, 0.92], [200_000, 769, 1149, 0.49, 0.72],
  [300_000, 1069, 1599, 0.45, 0.67], [400_000, 1269, 1899, 0.4, 0.6], [500_000, 1499, 2199, 0.38, 0.55],
  [750_000, 1999, 2999, 0.34, 0.5], [1_000_000, 2199, 3299, 0.28, 0.42], [1_250_000, 2599, 3899, 0.26, 0.39],
  [1_500_000, 2999, 4499, 0.25, 0.38], [1_750_000, 3199, 4799, 0.23, 0.35],
  [2_000_000, 3389, 5099, 0.22, 0.32],
];
// Team (sensitivity row only; adds SAML SSO and 25 users), all 16 tiers from 2,000 tasks, same columns.
const ZAPIER_TEAM = [
  [2_000, 69, 103.5, 4.32, 6.47], [5_000, 119, 178.5, 2.98, 4.47], [10_000, 169, 253.5, 2.12, 3.17],
  [20_000, 249, 373.5, 1.56, 2.34], [50_000, 399, 598.5, 1, 1.5], [100_000, 599, 898.5, 0.75, 1.13],
  [200_000, 999, 1499, 0.63, 0.94], [300_000, 1199, 1799, 0.5, 0.75], [400_000, 1399, 2099, 0.44, 0.66],
  [500_000, 1799, 2699, 0.42, 0.63], [750_000, 2199, 3299, 0.37, 0.55], [1_000_000, 2499, 3749, 0.32, 0.47],
  [1_250_000, 2999, 4499, 0.3, 0.45], [1_500_000, 3399, 5099, 0.29, 0.43], [1_750_000, 3799, 5699, 0.28, 0.41],
  [2_000_000, 3999, 5999, 0.25, 0.38],
];
// Pay-per-task rate: the embedded rates come to about 1.25x each plan's own per-task price (1.17x to 1.30x)
// on yearly AND monthly billing. Zapier's blog https://zapier.com/blog/what-is-a-task-in-zapier/ (updated
// June 2026, read 2026-11-02) says "For annual plans, extra tasks are billed at 1.25x your plan's normal task
// cost. For monthly plans, the rate is 2.5x." The two Zapier sources disagree on monthly; the model uses the
// pricing page's plan data. The pricing page text says pay-per-task "is charged at a higher per-task rate than
// your base subscription tasks"; the help article says the rate "depends on your plan and billing cycle type".
// https://help.zapier.com/hc/en-us/articles/15279018245901 (read 2026-11-02): Zaps "will stop running if
// your account reaches the maximum pay-per-task usage amount. This is set at 3 times your plan's task limit".
const ZAPIER_MAX_MULTIPLE = 3;

// ---- Make ----
// https://www.make.com/en/pricing loads its price table from an API and returns a Cloudflare challenge to
// scripted fetches. We opened the page in a visible Chrome window on 2026-11-02, then read the table it
// requests with countryCode=US (the API reported variant "us"). Make quotes different USD lists by country.
// Plan ids 2, 3, 4 = Core, Pro, Teams: the cards Chrome showed us ($9, $16, $29 at 10,000 credits) match
// ids 2, 3, 4 in the list served to our location. Arrays are $ a month at each credit tier; null = not offered.
const MAKE_TIERS = [1000, 10000, 20000, 40000, 80000, 150000, 300000, 500000, 750000, 1000000, 1500000,
  2000000, 2500000, 3000000, 4000000, 5000000, 6000000, 7000000, 8000000];
const MAKE_US = {
  Core: {
    annual: [null, 12, 21, 38, 72, 129, 237, null, null, null, null, null, null, null, null, null, null, null, null],
    monthly: [null, 16, 28, 51, 97, 175, 321, null, null, null, null, null, null, null, null, null, null, null, null],
  },
  Pro: {
    annual: [null, 21, 38, 69, 118, 199, 349, 533, 750, 973, 1402, 1791, 2211, 2579, 3347, 4100, 4820, 5556, 6255],
    monthly: [null, 28, 51, 94, 161, 271, 474, 724, 1018, 1321, 1903, 2431, 3002, 3501, 4543, 5566, 6542, 7543, 8491],
  },
  Teams: {
    annual: [null, 38, 69, 129, 225, 379, 663, 1013, 1425, 1821, 2561, 3187, 3912, 4481, 5726, 6934, 8245, 9396, 10700],
    monthly: [null, 51, 94, 175, 305, 515, 900, 1376, 1934, 2472, 3476, 4326, 5310, 6083, 7773, 9412, 11193, 12755, 14525],
  },
};
// https://help.make.com/extra-credits (read 2026-11-02): extra credits in "units of 1,000", "a 25% additional
// cost compared to the credits in your plan"; auto-purchase is limited "to the number of credits in your
// subscription". Pricing page FAQ: "Your scenarios won't continue to run, until credits are added again."
const MAKE_EXTRA_MULTIPLE = 1.25;
const MAKE_BUNDLE = 1000;
// ASSUMPTION: extra credits up to the tier's own credit count (Make's documented auto-purchase limit),
// otherwise the model moves up a tier or plan. Make states no limit for manual purchases; the sensitivities
// print the uncapped case.
const MAKE_EXTRA_CAP_MULTIPLE = 1;

// ---- n8n ----
// https://n8n.io/pricing/ (read 2026-11-02). "An execution is a single run of your entire workflow. It doesn't
// matter how many steps are in the workflow or how much data it processes." In Chrome the page showed USD
// (the same with a US and a German browser locale); the HTML the server sends before scripts run shows EUR.
// [executions a month, USD a month billed yearly, USD billed monthly, EUR per year billed yearly, EUR billed monthly]
const N8N_CLOUD = [
  ["Starter", 2_500, 20, 24, 240, 24],
  ["Pro 10k", 10_000, 50, 60, 600, 60],
  ["Pro 50k", 50_000, 120, 144, 1450, 145],
];
// Above 50,000 the Pro selector offers "Custom plan": no published Cloud price.
// Overage tooltip: "Starter and Pro are capped and have no overages."
// Business, "Self-hosted only": [executions, USD a month billed yearly, EUR per year]
const N8N_BUSINESS = [[40_000, 800, 8000], [50_000, 985, 9852], [75_000, 1456, 14555], [100_000, 1726, 17260],
  [150_000, 2189, 21890], [200_000, 2639, 26390], [300_000, 3512, 35120], [400_000, 4381, 43810],
  [500_000, 5245, 52450]];
// https://docs.n8n.io/build/understand-workflows/understand-executions (read 2026-11-02):
// Schedule Trigger nodes "Count one execution every time the node fires, regardless of outcome";
// polling nodes "Count one execution only when new data is found".
// FX for the EUR list only: https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml, read 2026-11-02,
// latest file dated 2026-10-30.
const ECB_DATE = "2026-10-30";
const ECB_USD_PER_EUR = 1.1172;

// ---- Self-hosted n8n Community ----
// https://www.digitalocean.com/pricing/droplets (read 2026-11-02): Basic droplet, 4 GiB, 2 vCPUs, "$ 24.00" a
// month; backups "set at 20 % (Weekly) or 30 % (Daily) of Droplet cost".
const DROPLET = 24;
const BACKUP_SHARE = 0.2;
// ASSUMPTION: one such droplet with Postgres on the same box runs all three workflows at every volume (not load-tested).
// ASSUMPTION: upkeep 2 / 4 / 8 hours a month (upgrades, backups checks, incidents), the same at every volume.
const UPKEEP_HOURS = { low: 2, mid: 4, high: 8 };
// ASSUMPTION: one-off setup 8 / 16 / 32 hours, printed apart from the monthly line.
const SETUP_HOURS = { low: 8, mid: 16, high: 32 };
// Loaded rate from https://keplaris.com/blogs/build-vs-buy-software: $194,000 a year (the BLS-based figure from
// https://keplaris.com/blogs/cost-to-build-a-saas-mvp-2026) / 2,080 paid hours, which that post rounds to $93.27 an hour.
const RATE = Math.round((194_000 / 2080) * 100) / 100;

// ---- Workflows: ASSUMPTIONS, defined step by step in the post ----
// W1 lead sync: form webhook trigger, filter out test leads, create CRM contact, post to Slack.
// W2 order pipeline: paid-order webhook, look up customer, branch (Paths / Router / IF), 2 actions on the
//    branch taken, Slack summary, loop over line items, update inventory per item. 3 line items on average.
// W3 hourly polling: check every 60 minutes; for each new item, upsert a CRM record and append a sheet row.
//    On W3, "runs" means new items found in the month; all items are processed by the poll that finds them.
const LINE_ITEMS = 3;
const POLLS_HOURLY = 24 * 30; // 720
const zapW2 = (items) => 1 + 0 + 2 + 1 + 0 + items;     // lookup, branch free, 2 actions, Slack, loop free, updates
const makeW2 = (items) => 1 + 1 + 0 + 2 + 1 + 1 + items; // trigger, lookup, router free, 2, Slack, iterator, updates
const WORKFLOWS = [
  { id: "W1", name: "lead sync, 3 steps", zap: () => 2, make: (r) => 3 * r, n8n: (r) => r },
  { id: "W2", name: "order pipeline, 7 steps with a branch", zap: () => zapW2(LINE_ITEMS), make: (r) => makeW2(LINE_ITEMS) * r, n8n: (r) => r },
  { id: "W3", name: "hourly polling job (runs = new items)", zap: () => 2, make: (r) => POLLS_HOURLY + 2 * r, n8n: (r) => Math.min(POLLS_HOURLY, r) },
];
const VOLUMES = [1_000, 10_000, 100_000];

// ---- helpers: money in integer cents, rounded half up only at the end ----
const cents = (usd) => Math.round(usd * 100);
const roundDiv = (num, den) => Math.floor((2 * num + den) / (2 * den));
const usd = (c) => "$" + (c / 100).toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
const n = (x) => x.toLocaleString("en-US");
const k = (x) => (x >= 1_000_000 ? x / 1_000_000 + "M" : x >= 1000 ? x / 1000 + "k" : String(x));
const eur = (x) => x.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 }) + " EUR";
const pad = (s, w) => String(s).padEnd(w);
const padS = (s, w) => String(s).padStart(w);

// Zapier: cheaper of the smallest tier that covers the need, and any lower tier plus pay-per-task (within 3x).
function zapier(tasks, tiers, billing) {
  const col = billing === "annual" ? 1 : 2;
  const pptCol = billing === "annual" ? 3 : 4;
  let best = null, cover = null;
  for (const t of tiers) {
    const price = cents(t[col]);
    let cost, extra = 0;
    if (t[0] >= tasks) cost = price;
    else if (tasks <= ZAPIER_MAX_MULTIPLE * t[0]) { extra = tasks - t[0]; cost = price + roundDiv(extra * Math.round(t[pptCol] * 100), 100); }
    else continue;
    if (t[0] >= tasks && !cover) cover = { tier: t[0], cost };
    if (!best || cost < best.cost) best = { tier: t[0], cost, extra };
  }
  if (!best) return null;
  best.cover = cover;
  return best;
}

// Make: Core first, Pro if Core cannot cover it; per plan, cheaper of covering tier and lower tier plus extras.
function makePlan(credits, plan, billing, capMultiple = MAKE_EXTRA_CAP_MULTIPLE) {
  const prices = MAKE_US[plan][billing];
  let best = null, cover = null;
  MAKE_TIERS.forEach((tier, i) => {
    if (prices[i] == null) return;
    const price = cents(prices[i]);
    let cost, extra = 0;
    if (tier >= credits) cost = price;
    else {
      extra = Math.ceil((credits - tier) / MAKE_BUNDLE) * MAKE_BUNDLE;
      if (extra > capMultiple * tier) return;
      cost = price + roundDiv(price * extra * 5, tier * 4);
    }
    if (tier >= credits && !cover) cover = { tier, cost };
    if (!best || cost < best.cost) best = { plan, tier, cost, extra };
  });
  if (best) best.cover = cover;
  return best;
}
const make = (credits, billing = "annual", cap = MAKE_EXTRA_CAP_MULTIPLE) =>
  makePlan(credits, "Core", billing, cap) || makePlan(credits, "Pro", billing, cap);

function n8nCloud(execs, billing = "annual") {
  for (const [name, cap, a, m] of N8N_CLOUD) if (execs <= cap) return { name, cap, cost: cents(billing === "annual" ? a : m) };
  return null;
}

const zapNote = (z) => z.extra
  ? `${k(z.tier)} tier + ${n(z.extra)} pay-per-task` + (z.cover ? `; next tier ${k(z.cover.tier)} ${usd(z.cover.cost)}` : "")
  : `${k(z.tier)} tier`;
const makeNote = (m) => m.extra
  ? `${m.plan} ${k(m.tier)} + ${n(m.extra)} extra credits` + (m.cover ? `; next tier ${k(m.cover.tier)} ${usd(m.cover.cost)}` : "")
  : `${m.plan} ${k(m.tier)}`;
const n8nNote = (c, execs) => c ? `${c.name}` + (execs === c.cap ? " (at its cap, no headroom)" : "") : "no published Cloud price";

const server = cents(DROPLET * (1 + BACKUP_SHARE));
const upkeep = (h) => cents(RATE) * h;
const selfHosted = (l) => server + upkeep(UPKEEP_HOURS[l]);

// ---- output ----
console.log(`automation cost model, list prices read ${READ}, USD a month, 30-day month, before tax`);
console.log(`node: ${process.version} | Make list: US variant | ECB rate ${ECB_DATE}: 1 EUR = ${ECB_USD_PER_EUR} USD`);
console.log("counting rules:");
console.log("  Zapier  1 task per successful action step; triggers, polls, Filter, Paths, Looping free");
console.log("  Make    1 credit per module run per bundle, trigger included on every check; Router, filters free");
console.log("  n8n     1 execution per workflow run, any number of steps; empty polls free, schedule fires counted");
console.log("  free plans excluded: Zapier Free allows two-step Zaps only, and every workflow here has more actions");

console.log(`\n== self-check: W2 per run, ${LINE_ITEMS} line items`);
console.log(`  Zapier ${zapW2(LINE_ITEMS)} tasks = lookup 1 + branch 0 + 2 actions + Slack 1 + loop 0 + ${LINE_ITEMS} updates`);
console.log(`  Make   ${makeW2(LINE_ITEMS)} credits = trigger 1 + lookup 1 + router 0 + 2 actions + Slack 1 + iterator 1 + ${LINE_ITEMS} updates`);
console.log(`  n8n    1 execution`);

console.log("\n== n8n plans as priced (USD list shown in Chrome; EUR list from the server HTML, converted at ECB)");
for (const [name, cap, a, m, eurYear, eurMonth] of N8N_CLOUD) {
  const ea = eurYear / 12;
  console.log(`  Cloud ${pad(name, 8)} ${padS(n(cap), 6)} execs  $${a}/mo yearly, $${m} monthly | ${eur(ea)}/mo yearly (about ${usd(cents(ea * ECB_USD_PER_EUR))}), ${eur(eurMonth)} monthly`);
}
for (const [cap, a, eurYear] of [N8N_BUSINESS[0], N8N_BUSINESS[3]]) {
  const ea = eurYear / 12;
  console.log(`  Business ${padS(n(cap), 7)} execs, self-hosted only: $${n(a)}/mo yearly | ${eur(ea)}/mo yearly (about ${usd(cents(ea * ECB_USD_PER_EUR))})`);
}

const grid = [];
for (const w of WORKFLOWS) {
  console.log(`\n== ${w.id} ${w.name}, annual billing`);
  for (const r of VOLUMES) {
    const tasks = w.zap() * r, credits = w.make(r), execs = w.n8n(r);
    const z = zapier(tasks, ZAPIER_PRO, "annual"), m = make(credits), c = n8nCloud(execs);
    grid.push({ w: w.id, r, z, m, c });
    console.log(`-- ${n(r)} ${w.id === "W3" ? "new items" : "runs"} a month`);
    console.log(`   Zapier ${padS(n(tasks), 9)} tasks       ${padS(usd(z.cost), 10)}  Pro ${zapNote(z)}`);
    console.log(`   Make   ${padS(n(credits), 9)} credits     ${padS(usd(m.cost), 10)}  ${makeNote(m)}`);
    const execLabel = w.id === "W3" ? `${padS("<= " + n(execs), 9)} executions` : `${padS(n(execs), 9)} executions`;
    console.log(`   n8n    ${execLabel}  ${padS(c ? usd(c.cost) : "n/a", 10)}  ${n8nNote(c, execs)}`);
  }
}

console.log("\n== self-hosted n8n Community: no licence fee, no execution quota");
console.log(`  server: droplet ${usd(cents(DROPLET))} + weekly backups ${usd(cents(DROPLET * BACKUP_SHARE))} = ${usd(server)}`);
console.log(`  upkeep at $${RATE.toFixed(2)}/hr: low ${UPKEEP_HOURS.low} h ${usd(upkeep(UPKEEP_HOURS.low))} | mid ${UPKEEP_HOURS.mid} h ${usd(upkeep(UPKEEP_HOURS.mid))} | high ${UPKEEP_HOURS.high} h ${usd(upkeep(UPKEEP_HOURS.high))}`);
console.log(`  total a month: low ${usd(selfHosted("low"))} | mid ${usd(selfHosted("mid"))} | high ${usd(selfHosted("high"))} (same at every volume)`);
console.log(`  one-off setup, not in the monthly line: ${SETUP_HOURS.low} h ${usd(upkeep(SETUP_HOURS.low))} | ${SETUP_HOURS.mid} h ${usd(upkeep(SETUP_HOURS.mid))} | ${SETUP_HOURS.high} h ${usd(upkeep(SETUP_HOURS.high))}`);
for (const [execs, label] of [[10_000, "10,000"], [100_000, "100,000"]]) {
  const b = N8N_BUSINESS.find((t) => t[0] >= execs);
  console.log(`  self-hosted Business at ${label} executions: ${k(b[0])} plan $${n(b[1])} + server + mid upkeep = ${usd(cents(b[1]) + selfHosted("mid"))}`);
}

console.log("\n== summary, USD a month, annual billing (n8n self-hosted = Community at mid upkeep)");
console.log("  workflow, volume    Zapier      Make        n8n Cloud   n8n self-hosted   lowest of the three services");
for (const g of grid) {
  const opts = [["Zapier", g.z.cost], ["Make", g.m.cost]].concat(g.c ? [["n8n Cloud", g.c.cost]] : []);
  const low = opts.reduce((a, b) => (b[1] < a[1] ? b : a));
  console.log(`  ${pad(g.w + " " + n(g.r), 18)}${padS(usd(g.z.cost), 10)}  ${padS(usd(g.m.cost), 10)}  ${padS(g.c ? usd(g.c.cost) : "no price", 10)}  ${padS(usd(selfHosted("mid")), 15)}   ${low[0]}${g.c ? "" : " (n8n Cloud has no published price)"}`);
}

console.log("\n== batch case: one poll returns 500 new rows, each row goes through 2 actions");
console.log(`  Zapier ${n(500 * 2)} tasks (one Zap run per new item) | Make ${n(1 + 500 * 2)} credits (trigger 1 + 500 x 2) | n8n 1 execution`);

console.log("\n== sensitivities");
for (const r of [1_000, 10_000, 100_000]) {
  const zm = zapier(zapW2(LINE_ITEMS) * r, ZAPIER_PRO, "monthly"), mm = make(makeW2(LINE_ITEMS) * r, "monthly"), cm = n8nCloud(r, "monthly");
  console.log(`  monthly billing, W2 ${pad(n(r), 7)}: Zapier ${usd(zm.cost)} (${zapNote(zm)}) | Make ${usd(mm.cost)} (${makeNote(mm)}) | n8n ${cm ? usd(cm.cost) : "no published Cloud price"}`);
}
const zt = zapier(zapW2(LINE_ITEMS) * 10_000, ZAPIER_TEAM, "annual");
const mt = makePlan(makeW2(LINE_ITEMS) * 10_000, "Teams", "annual");
console.log(`  Zapier Team, W2 10,000: ${usd(zt.cost)} (${zapNote(zt)}) | Make Teams, W2 10,000: ${usd(mt.cost)} (${makeNote(mt)})`);
const mu = make(makeW2(LINE_ITEMS) * 100_000, "annual", Infinity);
console.log(`  Make extra credits uncapped (manual purchase), W2 100,000: ${usd(mu.cost)} (${makeNote(mu)})`);
for (const items of [1, 10]) {
  const z = zapier(zapW2(items) * 10_000, ZAPIER_PRO, "annual"), m = make(makeW2(items) * 10_000);
  console.log(`  W2 10,000 runs with ${pad(items + " line item" + (items > 1 ? "s" : ""), 13)}: Zapier ${zapW2(items)}/run ${usd(z.cost)} | Make ${makeW2(items)}/run ${usd(m.cost)} | n8n 1/run ${usd(n8nCloud(10_000).cost)}`);
}
const POLLS_5MIN = 12 * 24 * 30;
for (const r of [1_000, 10_000]) {
  const m = make(POLLS_5MIN + 2 * r), cs = n8nCloud(POLLS_5MIN), cp = n8nCloud(Math.min(POLLS_5MIN, r));
  console.log(`  W3 polling every 5 min (${n(POLLS_5MIN)} checks), ${n(r)} items: Make ${n(POLLS_5MIN + 2 * r)} credits ${usd(m.cost)} | n8n Schedule Trigger ${n(POLLS_5MIN)} execs ${usd(cs.cost)}, polling node <= ${n(Math.min(POLLS_5MIN, r))} ${usd(cp.cost)}`);
}

console.log("\n== traced: W2 at 10,000 runs a month, annual billing");
{
  const r = 10_000, tasks = zapW2(LINE_ITEMS) * r, z = zapier(tasks, ZAPIER_PRO, "annual");
  const t = ZAPIER_PRO.find((x) => x[0] === z.tier);
  console.log(`  Zapier ${n(tasks)} tasks: ${k(t[0])} tier $${t[1]} + ${n(z.extra)} x ${t[3]} cents pay-per-task = ${usd(z.cost)}; ${k(z.cover.tier)} tier ${usd(z.cover.cost)}`);
  const credits = makeW2(LINE_ITEMS) * r, m = make(credits);
  const mp = MAKE_US[m.plan].annual[MAKE_TIERS.indexOf(m.tier)];
  console.log(`  Make ${n(credits)} credits: ${m.plan} ${k(m.tier)} $${mp} + ${n(m.extra)} x ($${mp} / ${n(m.tier)}) x ${MAKE_EXTRA_MULTIPLE} = ${usd(m.cost)}; next tier ${usd(m.cover.cost)}`);
  const c = n8nCloud(r), c50 = N8N_CLOUD[2];
  console.log(`  n8n ${n(r)} executions: Cloud ${c.name} ${usd(c.cost)}, at its cap; Pro 50k for headroom $${c50[2]}.00`);
}

The unedited output of node cost-model.mjs from 2026-11-02:

automation cost model, list prices read 2026-11-02, USD a month, 30-day month, before tax
node: v24.20.0 | Make list: US variant | ECB rate 2026-10-30: 1 EUR = 1.1172 USD
counting rules:
  Zapier  1 task per successful action step; triggers, polls, Filter, Paths, Looping free
  Make    1 credit per module run per bundle, trigger included on every check; Router, filters free
  n8n     1 execution per workflow run, any number of steps; empty polls free, schedule fires counted
  free plans excluded: Zapier Free allows two-step Zaps only, and every workflow here has more actions

== self-check: W2 per run, 3 line items
  Zapier 7 tasks = lookup 1 + branch 0 + 2 actions + Slack 1 + loop 0 + 3 updates
  Make   9 credits = trigger 1 + lookup 1 + router 0 + 2 actions + Slack 1 + iterator 1 + 3 updates
  n8n    1 execution

== n8n plans as priced (USD list shown in Chrome; EUR list from the server HTML, converted at ECB)
  Cloud Starter   2,500 execs  $20/mo yearly, $24 monthly | 20.00 EUR/mo yearly (about $22.34), 24.00 EUR monthly
  Cloud Pro 10k  10,000 execs  $50/mo yearly, $60 monthly | 50.00 EUR/mo yearly (about $55.86), 60.00 EUR monthly
  Cloud Pro 50k  50,000 execs  $120/mo yearly, $144 monthly | 120.83 EUR/mo yearly (about $135.00), 145.00 EUR monthly
  Business  40,000 execs, self-hosted only: $800/mo yearly | 666.67 EUR/mo yearly (about $744.80)
  Business 100,000 execs, self-hosted only: $1,726/mo yearly | 1,438.33 EUR/mo yearly (about $1,606.91)

== W1 lead sync, 3 steps, annual billing
-- 1,000 runs a month
   Zapier     2,000 tasks           $49.00  Pro 2k tier
   Make       3,000 credits         $12.00  Core 10k
   n8n        1,000 executions      $20.00  Starter
-- 10,000 runs a month
   Zapier    20,000 tasks          $189.00  Pro 20k tier
   Make      30,000 credits         $34.13  Core 20k + 10,000 extra credits; next tier 40k $38.00
   n8n       10,000 executions      $50.00  Pro 10k (at its cap, no headroom)
-- 100,000 runs a month
   Zapier   200,000 tasks          $769.00  Pro 200k tier
   Make     300,000 credits        $237.00  Core 300k
   n8n      100,000 executions         n/a  no published Cloud price

== W2 order pipeline, 7 steps with a branch, annual billing
-- 1,000 runs a month
   Zapier     7,000 tasks          $129.00  Pro 10k tier
   Make       9,000 credits         $12.00  Core 10k
   n8n        1,000 executions      $20.00  Starter
-- 10,000 runs a month
   Zapier    70,000 tasks          $435.00  Pro 50k tier + 20,000 pay-per-task; next tier 100k $489.00
   Make      90,000 credits         $83.25  Core 80k + 10,000 extra credits; next tier 150k $129.00
   n8n       10,000 executions      $50.00  Pro 10k (at its cap, no headroom)
-- 100,000 runs a month
   Zapier   700,000 tasks        $1,999.00  Pro 750k tier
   Make     900,000 credits        $937.50  Pro 750k + 150,000 extra credits; next tier 1M $973.00
   n8n      100,000 executions         n/a  no published Cloud price

== W3 hourly polling job (runs = new items), annual billing
-- 1,000 new items a month
   Zapier     2,000 tasks           $49.00  Pro 2k tier
   Make       2,720 credits         $12.00  Core 10k
   n8n       <= 720 executions      $20.00  Starter
-- 10,000 new items a month
   Zapier    20,000 tasks          $189.00  Pro 20k tier
   Make      20,720 credits         $22.31  Core 20k + 1,000 extra credits; next tier 40k $38.00
   n8n       <= 720 executions      $20.00  Starter
-- 100,000 new items a month
   Zapier   200,000 tasks          $769.00  Pro 200k tier
   Make     200,720 credits        $183.83  Core 150k + 51,000 extra credits; next tier 300k $237.00
   n8n       <= 720 executions      $20.00  Starter

== self-hosted n8n Community: no licence fee, no execution quota
  server: droplet $24.00 + weekly backups $4.80 = $28.80
  upkeep at $93.27/hr: low 2 h $186.54 | mid 4 h $373.08 | high 8 h $746.16
  total a month: low $215.34 | mid $401.88 | high $774.96 (same at every volume)
  one-off setup, not in the monthly line: 8 h $746.16 | 16 h $1,492.32 | 32 h $2,984.64
  self-hosted Business at 10,000 executions: 40k plan $800 + server + mid upkeep = $1,201.88
  self-hosted Business at 100,000 executions: 100k plan $1,726 + server + mid upkeep = $2,127.88

== summary, USD a month, annual billing (n8n self-hosted = Community at mid upkeep)
  workflow, volume    Zapier      Make        n8n Cloud   n8n self-hosted   lowest of the three services
  W1 1,000              $49.00      $12.00      $20.00          $401.88   Make
  W1 10,000            $189.00      $34.13      $50.00          $401.88   Make
  W1 100,000           $769.00     $237.00    no price          $401.88   Make (n8n Cloud has no published price)
  W2 1,000             $129.00      $12.00      $20.00          $401.88   Make
  W2 10,000            $435.00      $83.25      $50.00          $401.88   n8n Cloud
  W2 100,000         $1,999.00     $937.50    no price          $401.88   Make (n8n Cloud has no published price)
  W3 1,000              $49.00      $12.00      $20.00          $401.88   Make
  W3 10,000            $189.00      $22.31      $20.00          $401.88   n8n Cloud
  W3 100,000           $769.00     $183.83      $20.00          $401.88   n8n Cloud

== batch case: one poll returns 500 new rows, each row goes through 2 actions
  Zapier 1,000 tasks (one Zap run per new item) | Make 1,001 credits (trigger 1 + 500 x 2) | n8n 1 execution

== sensitivities
  monthly billing, W2 1,000  : Zapier $193.50 (10k tier) | Make $16.00 (Core 10k) | n8n $24.00
  monthly billing, W2 10,000 : Zapier $651.50 (50k tier + 20,000 pay-per-task; next tier 100k $733.50) | Make $112.16 (Core 80k + 10,000 extra credits; next tier 150k $175.00) | n8n $60.00
  monthly billing, W2 100,000: Zapier $2,999.00 (750k tier) | Make $1,272.50 (Pro 750k + 150,000 extra credits; next tier 1M $1,321.00) | n8n no published Cloud price
  Zapier Team, W2 10,000: $599.00 (50k tier + 20,000 pay-per-task; next tier 100k $599.00) | Make Teams, W2 10,000: $260.16 (Teams 80k + 10,000 extra credits; next tier 150k $379.00)
  Make extra credits uncapped (manual purchase), W2 100,000: $829.50 (Core 300k + 600,000 extra credits)
  W2 10,000 runs with 1 line item  : Zapier 5/run $289.00 | Make 7/run $72.00 | n8n 1/run $50.00
  W2 10,000 runs with 10 line items: Zapier 14/run $737.00 | Make 16/run $139.75 | n8n 1/run $50.00
  W3 polling every 5 min (8,640 checks), 1,000 items: Make 10,640 credits $13.50 | n8n Schedule Trigger 8,640 execs $50.00, polling node <= 1,000 $20.00
  W3 polling every 5 min (8,640 checks), 10,000 items: Make 28,640 credits $32.81 | n8n Schedule Trigger 8,640 execs $50.00, polling node <= 8,640 $50.00

== traced: W2 at 10,000 runs a month, annual billing
  Zapier 70,000 tasks: 50k tier $289 + 20,000 x 0.73 cents pay-per-task = $435.00; 100k tier $489.00
  Make 90,000 credits: Core 80k $72 + 10,000 x ($72 / 80,000) x 1.25 = $83.25; next tier $129.00
  n8n 10,000 executions: Cloud Pro 10k $50.00, at its cap; Pro 50k for headroom $120.00

The output is a snapshot of three vendors' list prices on 2026-11-02 and our stated assumptions; it leaves out AI token bills, build and migration time, discounts and tax.

How Keplaris approaches automation platforms

We build client automations on n8n, Make and custom Node.js, which is why the model is public for you to check and why the table above still names Zapier where it fits. In practice we start from the shape of the workflow: count its steps, loops and polls in each vendor's unit, price it at the volume you expect next year, then decide who will maintain it. If your workflows have outgrown the plan they're on, our Automation & AI Systems team can price the move with you.