Contents
Fast answer
These two meter completely differently, and that is the whole comparison. Latenode bills CPU seconds of actual runtime: 10,000 free a month, then $0.00012 per CPU second from 10,001 to 100,000, stepping down to $0.00005 above 5,000,001, with no base fee on pay as you go. Make bills credits: Free at $0 for 1,000 credits a month with 2 active scenarios and a 15 minute minimum interval, Core at $9 a month for 10,000 credits with unlimited scenarios and a one minute interval, Pro at $16 and Teams at $29 on the same 10,000 credit base. So Latenode charges for how long your workflows take and Make charges for how much they do. A fast workflow with many steps is cheap on Latenode and expensive on Make. A workflow that waits on a slow API is the reverse. Neither rate matters until you know which shape yours are.
Facts last verified 2026-08
Quick facts
- Latenode meter
- CPU seconds of actual runtime
- Make meter
- Credits consumed by operations
- Latenode free
- 10,000 CPU seconds, 5 workflows, 3 minute run cap, 3 days history
- Latenode paid
- $0.00012 down to $0.00005 per CPU second, no base fee
- Make Free
- $0, 1,000 credits, 2 scenarios, 15 minute minimum interval
- Make Core
- $9/mo, 10,000 credits, unlimited scenarios, 1 minute interval
- Rule of thumb
- Waiting workflows favour Make; short frequent runs favour Latenode
On this page
What this page covers
A comparison visitor should understand the tradeoff, the best-fit scenario, and the next diagnostic tool to confirm the choice.
- 01Quick verdict
- 02Pricing
- 03The meter
- 04Building experience
- 05Decision table
- 06Where both are wrong
Why does this matter now?
Comparing $0.00012 a CPU second against $9 a month for 10,000 credits is not a comparison, it is two unrelated numbers. The only honest way to choose is to take a workflow you actually intend to run, measure it on both, and see which meter treats it kindly. Almost nobody does this, which is why so many teams end up on a platform whose economics fight their design.
Internal path
Where to go next from this page
These links are part of the A8gent learning and conversion path. Use them to move from concept, to diagnosis, to workflow build, to course.
What you should be able to do after this
- Match the meter to your workflow shape
- Price the same workload on both
- Spot which workflows punish runtime billing
- Choose without guessing at units
How do you do it, step by step?
1. Classify your workflows as fast or waiting
Fast workflows do work and finish: read a webhook, transform data, write a record. Waiting workflows poll a slow endpoint, sit through a long AI generation, or sleep between retries. Latenode charges for elapsed time, so waiting workflows are expensive there and effectively free on a credit meter. This single distinction decides most cases.
2. Count steps, because Make charges for them
Make's credits are consumed by operations, so a scenario with thirty steps consumes far more than one with three at the same trigger frequency. Core's 10,000 credits a month sounds generous and covers roughly 333 runs of a thirty-step scenario. Count your steps per run before assuming the allowance covers your volume.
3. Check the run-time and interval limits
Latenode caps runs at 3 minutes on Free and 10 minutes on pay as you go, extendable to 60 via a $10 to $30 a month add-on. Make's free tier has a 15 minute minimum interval between runs, dropping to one minute on Core and above. Those two limits catch people out more often than the rates do.
4. Price the add-ons that are not in the headline
Latenode charges separately for reserved execution workers at $10 a month each, extended run times at $10 to $30, faster polling at $5 to $10, higher file limits at $5 to $70, extra RAG storages at $10 each and high-volume event filtering at $20. Make's tiers bundle more of this, so compare totals rather than base rates.
Pick Latenode when, pick Make when
Pick Latenode when your workflows are short, frequent and finish fast. It meters CPU seconds of actual runtime, with 10,000 free a month and then $0.00012 per CPU second from 10,001 to 100,000, stepping down through the bands to $0.00005 above 5,000,001, with no base fee on pay as you go. A twenty-step workflow that completes in two seconds costs two CPU seconds regardless of how many steps it had, which is the shape this meter was built to reward.
Pick Latenode also when your team is technical enough to want code inside a workflow and disciplined enough to measure runtime. The billing model gives you a direct lever that most platforms do not: making a workflow faster makes it cheaper, in proportion. For a team that will actually profile and optimise, that is a satisfying relationship between engineering effort and cost, and it can make heavy workloads remarkably inexpensive.
Pick Make when your scenarios wait on external services, or when you want the lowest published entry price with a familiar visual canvas. Core is $9 a month for 10,000 credits with unlimited active scenarios and a one minute minimum interval, Pro is $16 and Teams is $29 on the same credit base, against a free tier of 1,000 credits, 2 scenarios and a 15 minute interval. Waiting is not billed at all, so a scenario polling a slow API costs the same as one that returns instantly.
Pick Make also when a non-technical person needs to build and maintain the automations. The canvas is more established, more widely known, and closer to how most people coming from other no-code tools already think. That familiarity is worth real money in a small team, because a platform nobody but one person can edit is a platform with a single point of failure regardless of what it charges.
One charges for time, the other for operations
These two meters produce opposite rankings on the same workload, which is why comparing headline rates is meaningless. Take a scenario with thirty steps that completes in two seconds, run 500 times a month. On Latenode that is 1,000 CPU seconds, comfortably inside the free allowance, so it costs nothing. On Make each of those thirty steps consumes credits, so 500 runs is roughly 15,000 credits, which exceeds Core's 10,000 monthly allowance at $9 and pushes you up the slider.
Now invert the shape. Take a scenario with three steps that waits five minutes on a slow external API, run 500 times a month. On Latenode that is 150,000 CPU seconds, billing 140,000 after the free allowance at $0.00012, which is roughly $16.80. On Make it is roughly 1,500 credits, comfortably inside Core's 10,000 at $9. Same platforms, same volumes, opposite winner, and the only thing that changed was the shape of the work.
The uncomfortable part is that almost nobody can classify their own workflows this way before building them. Ask a team how many scenarios they need and they can answer. Ask how many steps each has and they can approximate. Ask how many seconds each takes to run and you will get a guess, because nobody has measured it. Latenode's meter demands precisely the number that does not exist yet.
So the honest method is to build one representative workflow on Latenode's free 10,000 CPU seconds and Make's free 1,000 credits, run it fifty times on each, and read the actual consumption. That is an afternoon of work and it replaces two guesses with two measurements. Every other approach to this comparison is a spreadsheet exercise that gets contradicted by the first real invoice.
Where both of these are the wrong answer
Neither is right if you need the broadest possible connector catalogue. Zapier Professional runs from $19.99 a month billed annually at 750 tasks up to $489 at 100,000, with Team from $69 a month annually, and its app coverage is the widest in the category. If your constraint is that a specific business tool must be supported today without custom work, that breadth matters more than either meter and both of these platforms will lose that comparison.
Neither is right if execution volume is high and you want the cost per run to be flat and predictable. n8n Cloud starts at EUR 20 a month billed annually for 2,500 executions with 5 concurrent, Pro is EUR 50 for 10,000 with 20 concurrent, and the Community edition self-hosts free with unlimited executions. Metering by execution means neither step count nor duration affects the bill, which is the simplest model of the four to forecast.
Neither is right if the add-ons you need cost more than the platform. Latenode charges separately for reserved execution workers at $10 a month each, extended run times at $10 to $30, faster polling at $5 to $10, higher file limits at $5 to $70, extra RAG storages at $10 each and high-volume event filtering at $20. A workflow needing a long run and dedicated capacity can add more in fixed add-ons than it consumes in metered runtime, which undermines the whole reason for choosing a usage meter.
And neither is right if the free tier limits will shape your design badly. Latenode's free plan caps a single run at 3 minutes, allows 5 active scenarios and gives 1 execution worker with 3 days of execution history. Make's free tier gives 1,000 credits, 2 active scenarios and a 15 minute minimum interval between runs. Both are prototype allowances, and building around them rather than around your actual requirements produces workflows you will have to rewrite.
How to check this yourself, and what we did not test
All figures on this page were read from each vendor's own pricing page on 20 August 2026 and the source URLs are listed below. Latenode's CPU second bands came from latenode.com/pricing and Make's credit tiers from make.com/en/pricing. Both publish sliders and add-on lists that are easy to misread from a summary, so confirm the specific band and tier that apply to your volume.
We did not measure execution speed on either platform, which is a real limitation given that Latenode bills for exactly that. Two platforms running identical logic may not consume identical time, and we have no data comparing them. We also did not test connector reliability or error handling. This page separates them on metering model and published limits only.
The test that settles it costs nothing. Build one representative workflow on Latenode's free 10,000 CPU seconds and on Make's free 1,000 credits, run it fifty times on each, and read the actual consumption. That replaces two guesses with two measurements, and it is the only method that survives contact with a real invoice.
At a glance
Latenode vs Make decision table, read from each vendor's own pricing page on 20 August 2026
| Decision factor | Latenode | Make |
|---|---|---|
| Metered unit | CPU second of runtime | Credit, consumed by operations |
| Free tier | 10,000 CPU seconds, 5 active workflows, 1 worker | 1,000 credits, 2 active scenarios |
| Entry paid price | No base fee; usage only after 10,000 free CPU seconds | Core $9/mo for 10,000 credits |
| Higher tiers | Rates step down to $0.00005 per CPU second above 5,000,001 | Pro $16/mo, Teams $29/mo on the same 10,000 credit base |
| Max run time | 3 minutes free, 10 minutes pay as you go, 60 with an add-on | Not the constraint; interval is |
| Minimum interval | Not the constraint; runtime is | 15 minutes on Free, 1 minute on Core and above |
| Execution history | 3 days free, 30 days pay as you go | See the platform page |
| Add-ons | Workers $10/mo, run time $10-$30, polling $5-$10, files $5-$70, RAG $10, filtering $20 | Bundled into the tier |
| Cost of waiting | Billed for every idle second | Not billed for waiting |
| Cost of many steps | Not billed per step | Each operation consumes credits |
What mistakes should you avoid?
- Comparing CPU seconds against credits without modelling a real workflow on both
- Polling a slow API on Latenode and paying for every idle second
- Building thirty-step scenarios on Make Core and exhausting 10,000 credits quickly
- Missing Latenode's 3 minute run cap on the free plan
- Ignoring Make's 15 minute minimum interval on the free tier
- Comparing base rates when Latenode's add-ons are fixed monthly costs on top
FAQ
- Which is cheaper, Latenode or Make?
- It depends entirely on workflow shape. Latenode bills $0.00012 down to $0.00005 per CPU second with 10,000 free a month; Make Core is $9 a month for 10,000 credits. Fast, frequent, short workflows favour Latenode. Multi-step scenarios and anything that waits favour Make. Model your own workload on both before deciding.
- What is a CPU second and what is a credit?
- A CPU second is one second of actual workflow runtime, so it measures duration. A Make credit is consumed by an operation, so it measures work done. A ten-second workflow with two steps costs ten CPU seconds and two credits; a one-second workflow with twenty steps costs one CPU second and twenty credits.
- Which has the better free tier?
- They constrain differently. Latenode gives 10,000 CPU seconds, 5 active workflows, 1 worker, a 3 minute run cap and 3 days of history. Make gives 1,000 credits, 2 active scenarios and a 15 minute minimum interval. Make's interval limit is the more restrictive for anything that needs to respond promptly.
- Which is easier to build on?
- Make's visual canvas is more established and more familiar to people coming from other no-code tools. Latenode's appeal to technical users is that you can drop into code inside a workflow. If your team is non-technical, that difference matters more than either meter.
Sources & further reading
Done for you
Want this built for your business?
Tell us the workflow. We scope, build, and ship the agent with guardrails and the numbers to prove it worked. The scoping call is free.
Free scoping call. You own the code.
Was this page helpful?

