Contents
- Verdict
- What is Latenode?
- Best for, and not for
- Strengths and limits
- Pricing
- What people actually build with it
- What Latenode actually costs at real volume
- The gotcha: you are billed for waiting, not for working
- What breaks in production, and how you find out
- What it connects to that you already run
- Latenode alternatives: what to pick instead, and when
- Migration and lock-in: can you get your work out?
- FAQ
Latenode is worth it if your workflows are step-heavy and fast, and a bad deal if they are step-light and slow, because it bills by runtime rather than by task. As of August 2026 it charges in CPU seconds: the first 10,000 CPU seconds each month are free on every plan, then pay-as-you-go rates run from $0.00012 per CPU second in the 10,001 to 100,000 band down to $0.00005 per second above five million. The free plan gives 5 active scenarios, a 3 minute cap per run and 1 execution worker. Pay as you go has no base fee, unlimited active scenarios, a 10 minute run cap and 3 workers. For most ordinary automation volumes this makes Latenode effectively free, which is not a sentence you can write about any of its competitors.
What is Latenode?
Latenode is a low-code automation platform that combines a visual builder with JavaScript nodes, and bills by execution time instead of per task or operation. It bundles access to hundreds of AI models, including OpenAI, Claude, and Gemini, without you managing separate API keys, and includes an AI code generator that writes JavaScript nodes for integrations it does not have pre-built. Its pitch is Zapier-style automation at a fraction of the cost at volume.
Best for
Cost-conscious builders running high-volume automations who do not mind a rougher, newer platform.
Not for
Workflows that sit waiting on slow external APIs or long AI generations, because you are billed for the waiting.
Strengths
- Billing by CPU second means step count is free, so filters, branches and helper nodes cost nothing extra, which is the exact opposite of per-task pricing
- The first 10,000 CPU seconds a month are free on every plan, which covers a genuinely useful amount of real automation before any money changes hands
- Pay as you go has no base subscription fee at all, so a quiet month costs nothing rather than costing a plan fee
- Rates step down with volume, from $0.00012 to $0.00005 per CPU second, so the platform gets cheaper per unit exactly when you are using it most
- Unlimited active scenarios on pay as you go removes the scenario-count ceiling that forces plan upgrades on competing platforms
- Latenode publishes the full tiered rate table rather than a single headline rate, so you can model a bill before committing
- Add-ons are itemised and cheap individually, from $5 polling intervals to $10 reserved workers, rather than being bundled into a forced tier jump
Limitations
- Runtime billing punishes waiting, so a workflow that polls a slow API or waits on a long AI generation pays for idle seconds it did not choose
- The free plan caps runs at 3 minutes and pay as you go at 10 minutes, so long jobs need paid execution-time add-ons at $10 to $30 a month
- A 1 CPU second minimum charge per execution on the free plan means very short, very frequent runs are billed above their true cost
- The free plan allows only 5 active scenarios and 1 execution worker, so concurrency is genuinely constrained until you move to pay as you go
- Execution history is 3 days on free and 30 on pay as you go, which is short if you need to investigate a failure someone reported late
- Plug and Play tokens at $1 each are a second currency sitting outside the runtime meter, so the CPU second total is not the whole bill
- Estimating a bill requires knowing your average runtime per run, which most people have never measured and cannot know before building
Latenode pricing
The billing unit is the CPU second, meaning compute time your scenarios actually use, and this is the single most important thing to understand about the platform. Latenode's own wording is that you pay for runtime, calculated as runs multiplied by seconds, and that step or task count does not multiply the bill by itself. So a fifteen-step workflow that completes in two seconds costs two CPU seconds, while a three-step workflow that waits eight seconds on a slow API costs eight. The first 10,000 CPU seconds every month are free. Beyond that, pay-as-you-go is tiered and gets cheaper as you use more: $0.00012 per CPU second from 10,001 to 100,000, $0.00011 from 100,001 to 200,000, and down to $0.00005 per second above 5,000,001. There is no base subscription fee on pay as you go. On the free plan a minimum charge of 1 CPU second applies per execution, so a sub-second run still counts as one. Two things sit outside the runtime meter: Plug and Play tokens, priced at 1 token equals $1, for optional nodes that use external paid resources, and add-ons for capacity such as reserved execution workers at $10 per worker per month.
| Plan | Price | What you get |
|---|---|---|
| Free | $0 | 10,000 CPU seconds a month, 5 active scenarios, 3 minute max run, 1 execution worker, 3 days execution history, 1 CPU second minimum charge per execution (as of Aug 2026) |
| Pay as you go | $0 base + usage | No base fee. First 10,000 CPU seconds free, then $0.00012 to $0.00005 per CPU second by volume band. Unlimited active scenarios, 10 minute max run, 3 execution workers, 30 days history |
| Usage band 10,001 to 100,000 | $0.00012/CPU sec | The first paid band. 100,000 CPU seconds of runtime costs about $10.80 after the free allowance |
| Usage band 5,000,001+ | $0.00005/CPU sec | The cheapest published band. Rates step down through the intervening bands as monthly volume rises |
| Add-ons | $5 to $70/mo | Reserved execution workers $10 each per month, high-volume event filtering $20, file size limits $5 to $70, execution time limits $10 to $30, polling intervals $5 to $10, extra RAG storages $10 each |
| Plug and Play tokens | 1 token = $1 | Charged separately from runtime, for optional nodes that use external paid resources |
Pricing reflects public plans as of August 6, 2026 and can change. Check Latenode for the latest.
What people actually build with it
Latenode's billing model selects for a particular kind of workflow, so the useful way to describe what people build is to sort it by whether the runtime meter rewards it or punishes it. The rewarded shape is many steps that execute fast. The punished shape is few steps that wait a long time.
Multi-branch inbox and form triage. A webhook fires when a form is submitted or a message lands, the scenario runs a dozen quick nodes to normalise fields, look up the sender against a database, branch on three conditions, format a response and write to two destinations. On a per-operation platform that is a dozen billable operations every time. On Latenode it is however many seconds the whole thing took, typically one or two. This is the archetypal Latenode build and it is where the cost difference against Make.com is largest.
Scheduled data consolidation. A scenario runs every hour, pulls records from an API, transforms them with JavaScript nodes rather than a chain of visual steps, deduplicates, and appends to a database. JavaScript is the important detail: a transformation that would be eight visual nodes elsewhere is one code node here, and because compute is what you pay for, doing the work in code is both faster and cheaper. Thirty seconds an hour is roughly 21,600 CPU seconds a month, which is the first workload in this list to leave the free tier, at about $1.40.
Enrichment and routing pipelines with heavy branching. Because filters and conditions do not carry a per-step charge, Latenode is a good home for the kind of workflow that has fifteen exit paths and validation at every stage. Teams that have been trained by per-task pricing to build minimal, fragile workflows can build defensively here without paying for the privilege, which is a real quality improvement and not just a cost one.
Webhook fan-out and internal glue. Receive an event, decide which of several downstream systems needs to know, call each one, log the result. Fast, high-frequency, low-duration work is exactly what the meter is kind to, subject to the 1 CPU second minimum charge per execution on the free plan, which means very short runs are rounded up.
The workload it is genuinely bad at, and this is worth being blunt about: anything that waits. A scenario that polls an external API for a job to complete, or that calls a slow AI model for a long generation, or that sits through rate limiting and retries, is being billed for time in which no useful work is happening. A three-step workflow that waits two minutes costs 120 CPU seconds, while a thirty-step workflow that finishes in two seconds costs two. If your automation's defining characteristic is patience, price it carefully or use a per-task platform.
The industry-shaped versions
An accounting firm runs a nightly scenario that pulls the day's transactions from a bookkeeping API, normalises them in a JavaScript node, flags anything outside expected ranges and writes an exception list. Thirty seconds a night is 900 CPU seconds a month, comfortably free. A dental practice runs a webhook-triggered scenario on each new booking that checks the record, formats a confirmation and queues an appointment reminder, at maybe two seconds a run.
An HVAC company runs an hourly scenario that reads new jobs, branches on job type across eight paths, and notifies the right technician group. On a per-operation platform those eight branches are a cost. Here they are free, and the whole thing lives inside the free allowance.
Where the JavaScript escape hatch earns its keep
Latenode pairs the drag-and-drop builder with JavaScript nodes and an AI code generator that writes them. Because you are billed for compute rather than for steps, moving logic into code is both faster and cheaper than expressing it as a chain of visual nodes, which reverses the usual incentive on no-code platforms.
The honest caveat is that generated code is code you now own, with no vendor maintaining it when the upstream API changes. Treat a generated node as a small piece of software with an owner, not as a connector.
Bottom line: Latenode rewards workflows with many fast steps and punishes workflows that wait, so a thirty-node scenario finishing in two seconds costs two CPU seconds while a three-node scenario waiting two minutes costs 120.
What Latenode actually costs at real volume
The formula is published and it is short: cost equals number of runs multiplied by average seconds per run, and the first 10,000 CPU seconds each month are free. Everything else is a rate lookup. Latenode's published bands as of August 2026 are $0.00012 per CPU second from 10,001 to 100,000, $0.00011 from 100,001 to 200,000, and $0.00005 above 5,000,001, with intervening bands stepping down between.
Run the reference workload. Inbox triage, 1,000 items a month, five steps per run, one AI model step. The five steps do not appear in the calculation at all, which is the whole point. What matters is how long a run takes. If the AI call returns in about two seconds and the other four steps are sub-second, call it 3 seconds a run. That is 1,000 times 3, or 3,000 CPU seconds a month, comfortably inside the free 10,000. The cost is $0.
Push the assumption and it stays cheap. At 10 seconds per run, which is a slow model call plus real API latency, you use exactly 10,000 CPU seconds and still pay nothing. At 20 seconds per run you use 20,000, of which 10,000 are free and 10,000 are billed at $0.00012, giving $1.20 a month. At a genuinely bad 60 seconds per run you use 60,000 seconds, pay for 50,000 at $0.00012, and the bill is $6.00. The reference workload does not meaningfully cost money on Latenode under any plausible assumption.
Compare that with the same workload elsewhere on this page. Bardeen prices it at $50 a month because it meters the AI step per row. Power Automate needs one Premium licence at $15 per user per month, which is $180 a year. A per-task platform charging on five steps would count 5,000 tasks a month. Latenode charges for three thousand seconds of compute and hands you the bill for nothing. At small and medium volumes this is not a marginal saving, it is a different category of cost.
Where the money actually appears is at volume or at duration. One hundred thousand runs a month at 3 seconds each is 300,000 CPU seconds: 10,000 free, then the bands, landing in the low tens of dollars. That is the number worth sitting with, because on a per-operation platform the same 100,000 runs at five steps each is half a million billable operations, and you should price that against your own plan rather than take our word for it. The second place money appears is the add-on list, which is itemised and easy to accumulate: $10 per reserved execution worker per month, $20 for high-volume event filtering, $5 to $70 for file size limits, $10 to $30 for execution time limits, $5 to $10 for polling intervals, $10 per extra RAG storage. None is large, several together are.
One cost that is not Latenode's and still lands on your card: if you call a frontier model through your own key, the token bill sits with the model provider. Whether you use Claude, ChatGPT or Gemini, that is a separate line, and on a runtime-billed platform a slower model costs you twice, once in tokens and once in CPU seconds.
| Average seconds per run | CPU seconds used | Billable after 10,000 free | Monthly cost |
|---|---|---|---|
| 1 second | 1,000 | 0 | $0 |
| 3 seconds | 3,000 | 0 | $0 |
| 10 seconds | 10,000 | 0 | $0 |
| 20 seconds | 20,000 | 10,000 | $1.20 |
| 60 seconds | 60,000 | 50,000 | $6.00 |
| 3 seconds, at 100,000 runs | 300,000 | 290,000 | Under $35, exact figure depends on bands above 200,000 that we could not read |
Bottom line: The reference workload of 1,000 inbox items a month costs Latenode nothing at any run duration up to 10 seconds, and $1.20 a month at 20 seconds, because step count never enters the calculation.
The gotcha: you are billed for waiting, not for working
Latenode's model is genuinely fairer than per-task pricing for most workloads, and it has one sharp edge that catches exactly the workflows people are most excited to build. You are billed for wall-clock runtime, and a scenario that is waiting is still running. The meter does not distinguish between a second spent computing and a second spent sitting on a slow API response.
This inverts the usual intuition about efficiency. On Zapier or Make.com, the way to save money is to use fewer steps. On Latenode, using fewer steps saves you nothing and can cost you more, because collapsing five fast operations into one node that makes a slow external call trades free step count for billed seconds. The optimisation that works here is reducing latency: parallelising independent calls, avoiding polling in favour of webhooks, and not putting a sleep in a scenario when a scheduled trigger would do.
AI steps are where this bites most often, and it is worth stating the number. A model call that streams a long response over eight seconds costs eight CPU seconds. At 1,000 runs a month that single step is 8,000 CPU seconds, which is most of your free allowance consumed by one node. The same call on a per-task platform is one task regardless of whether it took 200 milliseconds or 20 seconds. Latenode does list its AI Agent node as included on all plans with no charge beyond runtime, so there is no separate AI surcharge, but runtime is the surcharge.
The second edge is the run duration cap, which is a hard limit rather than a price. Free plans cap a run at 3 minutes and pay as you go at 10 minutes. If your scenario legitimately takes longer, you are not billed more, you are cut off, and the fix is an execution time add-on at $10 to $30 a month. That is cheap, but it is a thing to discover during design rather than during an incident.
The third is smaller and only matters at high frequency: the free plan applies a minimum charge of 1 CPU second per execution. A scenario that genuinely finishes in 50 milliseconds and fires 200,000 times a month is billed as 200,000 seconds rather than 10,000, a factor of twenty. Very short, very frequent runs are the one shape where per-execution rounding beats you.
The practical defence takes ten minutes and almost nobody does it. Build the scenario, run it twenty times, and read the actual execution durations rather than guessing them. Your average seconds per run is the single input the entire bill depends on, and it is the one number you can measure directly and cannot estimate reliably.
Bottom line: Latenode bills wall-clock runtime, so a waiting scenario is a paying scenario: an eight-second AI generation run 1,000 times consumes 8,000 of your 10,000 free CPU seconds from one node.
What breaks in production, and how you find out
The published operational limits tell you most of what will constrain a Latenode deployment, and they are more consequential than the pricing. Free plans get 1 execution worker, 5 active scenarios, a 3 minute run cap and 3 days of execution history. Pay as you go gets 3 execution workers, unlimited active scenarios, a 10 minute run cap and 30 days of history. Reserved execution workers are $10 each per month.
Execution workers are the first thing that hurts and the least intuitive. A worker is concurrency. With one worker, two events arriving simultaneously do not run simultaneously, they queue. For a scheduled hourly job this is invisible. For a webhook-triggered workflow that fires in bursts, it means latency that grows with the burst, and if the burst is large enough, work that arrives faster than it clears. The symptom is not an error message, it is things happening late, which is the failure mode nobody has an alert for.
The run duration caps are a hard stop. Three minutes on free, ten on pay as you go. A scenario that usually finishes in twenty seconds and occasionally waits on a degraded external API will hit that ceiling only on the days when the external system is already having a bad time, which is precisely when you least want a second failure. Design for it: split long work into stages triggered in sequence rather than one long scenario, or buy the execution time add-on at $10 to $30 a month before you need it.
Execution history length is the constraint that turns a small problem into an unsolvable one. Three days on the free plan means that a failure someone noticed on Friday and reported on Monday has no record left to investigate. Thirty days on pay as you go is workable but still short if a monthly reconciliation is how you discover discrepancies. If a workflow touches anything financial or contractual, write your own audit trail into a database you control rather than relying on the platform's retention.
Then there are the failure modes every automation platform shares, which are worth naming because they cause most real incidents regardless of vendor: a credential expires and every run fails identically until someone reconnects it; an upstream API changes a field name and the workflow succeeds while writing nulls; a rate limit starts rejecting calls at a volume you only reach in your busiest week. None of these announce themselves.
The discipline that catches all of them is the same one and it is boring. Add an explicit failure path to every production scenario that writes to a channel a human reads, and add a heartbeat: a scheduled scenario that checks whether the important workflow has run recently and shouts if it has not. Silent success and silent absence look identical from the outside, and on a platform where the free tier keeps three days of history, noticing late is the same as not noticing.
Execution workers are the limit that surprises people
One worker on free, three on pay as you go, $10 a month each after that. Workers are concurrency, and concurrency only matters when events arrive in bursts, which is exactly the pattern webhooks produce. A form that gets forty submissions in the ten minutes after an email campaign lands will queue behind a single worker, and the queue drains at whatever your average run duration is.
The symptom is latency rather than failure, which means no alert fires. If anything downstream is time-sensitive, such as a reply to a customer, buy the workers before you need them rather than diagnosing a delay after a complaint.
Build your own audit trail, whatever the plan
Three days of execution history on free and thirty on pay as you go is not enough for anything you might need to prove later. Write your own log row on every run, to a database or sheet you control, with a timestamp, the input identifier, the outcome and any error text.
That log costs you almost no runtime, survives any plan change, and is the difference between answering a customer dispute in five minutes and not being able to answer it at all. It is also the single most useful artefact if you ever migrate.
Bottom line: Latenode's real production constraints are concurrency and retention rather than cost: one execution worker on free means bursty webhooks queue, and three days of history means a failure reported on Monday has no record left.
What it connects to that you already run
Latenode's connector story has a different centre of gravity from the incumbents, and understanding it is more useful than a count. The platform combines a visual node builder with JavaScript nodes and an AI code generator that writes those nodes, which means the answer to a missing integration is usually to generate code against the API rather than to wait for a connector to be built.
That is a genuine strength and a genuine caveat in the same breath. The strength is that any system with an HTTP API is reachable today, without a feature request, and because compute is what you are billed for, a code node that does the work of eight visual steps is cheaper as well as faster. The caveat is that a generated JavaScript node is code you now own. It has no vendor maintaining it when the upstream API version changes, and the person who generated it may not be able to debug it.
For the systems a business already runs, the practical checklist is the ordinary one: your email and calendar, your CRM, your database or spreadsheet layer, your messaging tool, your payment processor. Latenode's pricing page also confirms a headless browser is included on all plans with no charge beyond runtime, which matters because it means scraping-adjacent work is possible server-side rather than requiring an extension-based tool like Bardeen. Runtime billing and a headless browser interact in a specific way worth knowing: browser automation is slow, so it consumes CPU seconds fast.
Two more pieces from the published add-on list tell you about scope. Extra RAG storages at $10 each per month indicate a built-in retrieval layer for AI workflows, so document-grounded agent work does not require a separate vector database subscription. Plug and Play tokens at 1 token equals $1 cover optional nodes that use external paid resources, which is the mechanism by which third-party paid services get billed through rather than around the platform.
If you are choosing between this and n8n on integration grounds, the honest distinction is not catalogue size, it is that n8n lets you run it yourself and Latenode, as far as the pricing page we checked shows, does not. For anything with a data residency requirement, that decides it.
Bottom line: Latenode answers a missing integration with generated JavaScript rather than a connector request, includes a headless browser and RAG storage add-ons at $10 each, and offers no self-hosted deployment.
Latenode alternatives: what to pick instead, and when
Latenode's pitch is that it is cheaper, and at the volumes most businesses actually run it is not just cheaper but free. So the alternatives question is rarely about price. It is about maturity, about self-hosting, and about whether runtime billing suits the shape of your work.
Every cost below is the same reference workload: inbox triage, 1,000 items a month, five steps a run, one AI model step.
| Tool | Billing unit | Cost at the reference workload | Suits | Does better than Latenode |
|---|---|---|---|---|
| Latenode | CPU second of runtime | $0, inside the free 10,000 CPU seconds | Step-heavy, fast workflows at any volume | Price, and not charging for workflow complexity |
| Make | Operation per step | 5,000 operations a month | Visual builders wanting maturity and community | Connector depth, tutorials, and a much larger community |
| n8n | Execution, or self-hosted for free | $0 self-hosted, plus your infrastructure | Technical teams and data residency requirements | Self-hosting, and full control of logs and data |
| Zapier | Task per step | 5,000 tasks a month | Non-technical teams wanting the widest catalogue | Breadth of integrations and speed to first working automation |
| Pipedream | Credit, with code-first workflows | Priced per credit against 1,000 runs | Developers who want code as the default | A code-first developer experience and ecosystem |
| Power Automate | User licence or capacity licence | $15/user/mo Premium, or $0 on standard connectors | Microsoft 365 organisations | Desktop RPA and deep Microsoft 365 integration |
When to pick the alternative, plainly
Pick Make.com or Zapier if you value the ecosystem more than the bill. Latenode is newer, its community is smaller, and the tutorial you need at 11pm is more likely to exist for the incumbents. If your automation is worth more than a few hundred dollars a year to the business, that difference can outweigh the saving, and we would rather say that than pretend price is the only axis.
Pick n8n if you need to run it yourself, whether for data residency, for a compliance review, or because you want the execution history on your own storage rather than in a 30 day window. Latenode's pricing page shows no self-hosted option, and that is a hard difference rather than a soft one.
Pick Pipedream if your team writes code by default and wants the workflow platform to feel like a codebase rather than a canvas. Latenode's JavaScript nodes are a good escape hatch, but an escape hatch is not the same thing as a code-first product.
Pick Power Automate if you are on Microsoft 365, because standard-connector cloud flows are already covered by a licence you own, and no amount of CPU-second efficiency beats zero.
Pick a per-task platform, counterintuitively, if your workflows are slow. Three steps that wait ninety seconds is three operations elsewhere and ninety CPU seconds here. Runtime billing is only a bargain when your runtime is short.
When Latenode is clearly the right answer
When volume is high, runs are fast, and workflows are complex. That combination is punished by every per-task and per-operation competitor and rewarded here, and the gap is not a few percent, it is a different order of magnitude. A hundred thousand fast runs a month with fifteen steps each is tens of dollars on Latenode.
If you want the arithmetic done against your own process rather than ours, a free automation audit will produce the runtime estimate that the whole bill depends on.
It is also the right answer when you want to build defensively. Adding validation, branching and a proper failure path to every workflow costs nothing on a runtime meter, whereas per-task pricing has quietly trained a generation of builders to ship fragile automations with no error handling because each check was a billable task.
Bottom line: Pick Latenode for high-volume, step-heavy, fast workflows where it costs a fraction of per-task competitors; pick n8n if you must self-host, Make or Zapier if ecosystem maturity matters more than price, and a per-task platform if your runs are slow.
Migration and lock-in: can you get your work out?
Commercially, Latenode has close to the weakest lock-in in this comparison, and that is a design choice rather than an accident. Pay as you go has no base subscription fee, so there is no annual commitment to strand and no plan to be stuck inside. Stop running scenarios and the bill goes to zero on its own. Compare that with Workato, where the price is a negotiated annual contract you cannot even see before entering a sales process, or with Power Automate, where the licences are per user paid yearly.
Technically the picture is more mixed and it splits along the visual-versus-code line. The visual scenarios are Latenode's own format and no competitor imports them, so moving those means rebuilding, which is true of every platform here. But the JavaScript nodes are the interesting part: that is ordinary code you wrote or generated, expressed against real APIs, and it ports to any environment that runs JavaScript. The more of your logic lives in code nodes rather than in visual chains, the cheaper your exit is. That is an unusual property and worth exploiting deliberately.
What does not port is the platform-specific scaffolding: the trigger configuration, the credential store, the scheduling, the branching structure between nodes, and anything that depends on Latenode's headless browser or its built-in AI model access. If you have leaned on the included AI Agent node rather than calling a model API directly, you have a dependency, because on another platform that call needs its own API key and its own billing relationship.
The execution history retention is a quiet lock-in of a different kind that people only notice on the way out. Three days on free and thirty on pay as you go means the operational record of what your automation did lives in a window that closes. If you ever need to prove what happened six months ago, whether for a customer dispute or an audit, the platform will not have it. Write your own log to storage you control from day one. This is good practice regardless of migration and it is the single most valuable thing you can do that costs nothing.
The realistic exit plan is therefore: keep business logic in JavaScript nodes where practical, keep your own execution log outside the platform, and maintain a plain-text description of each scenario's trigger, systems and outcome. Do those three things and moving to n8n, Make.com or a hosted build is a scoped week rather than an open-ended project. Skip them and you are reading a node graph trying to remember why a branch exists.
Bottom line: Latenode has the weakest commercial lock-in of the four, because pay as you go has no base fee and stopping costs nothing, and the more of your logic sits in JavaScript nodes the cheaper the technical exit becomes.
Latenode FAQ
How does Latenode pricing work?
Latenode bills in CPU seconds, which is compute time your scenarios use, not tasks or steps. Its own formulation is that cost equals runs multiplied by average seconds per run, and that step count does not multiply the bill by itself. The first 10,000 CPU seconds each month are free. After that, pay-as-you-go rates are tiered by volume: $0.00012 per CPU second from 10,001 to 100,000, $0.00011 from 100,001 to 200,000, stepping down to $0.00005 above five million. There is no base subscription fee on pay as you go, as of August 2026.
Does Latenode have a free plan?
Yes, and it is unusually substantial. The free plan gives 10,000 CPU seconds a month, 5 active scenarios, a 3 minute maximum run time, 1 execution worker and 3 days of execution history, with a minimum charge of 1 CPU second per execution. Because 10,000 CPU seconds is 10,000 one-second runs, a great many ordinary automations never leave it. The constraints that push people off free are usually not the seconds, they are the 5 active scenario limit and the single execution worker, which caps how much can run at once.
What does Latenode cost for 1,000 runs a month?
Do the arithmetic in the platform's own unit. For the reference workload of 1,000 inbox items a month, five steps each, one AI model step, the step count is irrelevant and only the seconds matter. If each run averages 3 seconds, that is 3,000 CPU seconds, which is inside the 10,000 free allowance, so the cost is $0. Even at 10 seconds per run you land on exactly 10,000 CPU seconds and still pay nothing. At 20 seconds per run you pay for 10,000 seconds at $0.00012, which is $1.20 a month.
Latenode vs Make: which is cheaper?
For step-heavy, fast workflows Latenode wins decisively, and the reason is structural. Make.com bills per operation, so a fifteen-step scenario costs fifteen operations every time it runs. Latenode bills the seconds, so those fifteen steps might cost two CPU seconds total. The comparison flips when workflows are slow rather than complex: a three-step scenario that waits ninety seconds on an external API is three operations on Make and ninety CPU seconds on Latenode. Measure your average runtime before assuming Latenode is cheaper, because for slow workflows it is not.
Does an AI step cost extra on Latenode?
It costs you the runtime it consumes, which is the honest catch with AI on a time-metered platform. A model call that takes eight seconds to generate is eight CPU seconds, whereas the same call on a per-task platform is one task regardless of duration. Latenode lists an AI Agent node as included on all plans with no charge beyond runtime, and an AI Code Copilot as pay-per-use without publishing a rate. Separately, Plug and Play tokens at 1 token equals $1 cover optional nodes that use external paid resources, so check whether the model node you pick draws those.
What is a CPU second and how is it measured?
It is a second of compute time your scenario uses while running. Latenode's documentation states that the first 10,000 CPU seconds each month are free and that a minimum charge of 1 CPU second per execution applies on the free plan, so a run that finishes in 200 milliseconds is still billed as one second. What the documentation we checked does not spell out is how time is rounded above that minimum, or precisely whether time spent waiting on an external response is billed the same as time spent computing. Both are worth confirming with support before you build something latency-heavy.
Is Latenode good for high volume?
It is where the model shines, because the rates step down as you use more. The published bands go from $0.00012 per CPU second at 10,001 to 100,000, through $0.00011 from 100,001 to 200,000, down to $0.00005 above five million. Combined with unlimited active scenarios on pay as you go, this means the per-unit price falls exactly when your volume rises, which is the opposite of hitting a plan ceiling and jumping a tier. The constraint to watch at volume is execution workers, since pay as you go includes 3 and extras are $10 each per month.
What are Latenode's hidden costs?
Three things sit outside the CPU second meter. Plug and Play tokens, at 1 token equals $1, for optional nodes that use external paid resources. Add-ons, which are itemised: reserved execution workers at $10 per worker per month, high-volume event filtering at $20, file size limits from $5 to $70, execution time limits from $10 to $30, polling intervals from $5 to $10, and extra RAG storages at $10 each. And the run duration caps themselves, 3 minutes on free and 10 minutes on pay as you go, since exceeding them means buying an execution time add-on.
Can you set this up for us?
Yes. Book a free automation consult, tell us the process, and we will scope it, tell you honestly whether Latenode is the right platform for it, and quote a fixed price in writing before we build. You own what we build, you get documentation, and you get a recurring plain-language report of what ran, what it saved and what needs attention. If your workload is genuinely inside Latenode's free 10,000 CPU seconds and you want to build it yourself, we will tell you that too, and point you at the arithmetic in this page.
Looking at alternatives? Latenode's pricing model is better designed than most of the category and we will say that plainly. Charging for compute rather than for steps is honest engineering economics: it stops punishing people for building well-structured workflows with proper error branches, and it makes the free tier meaningful rather than decorative. For a technical builder who wants to run high volumes cheaply and does not mind measuring their own runtimes, Latenode at effectively zero for ordinary volumes is very hard to argue with, and we would not try. Where a8gent differs is that we are not selling you a cheaper meter, we are selling you not having to think about the meter. The point is a process that is handled, with a plain-language report of what ran. If you enjoy the builder and want to run it yourself, run Latenode and keep the money. See the Autonoly review.
