Inngest Pricing 2026: Plans, Limits and Overage Costs
Nov 8, 202613 min read
The sticker is only the first line of the invoice.
Inngest has a free tier, a paid plan with a flat monthly starting price, and usage-based charges once you pass what each plan includes, which is a familiar shape if you've priced out other workflow tools like Activepieces too.
Inngest pricing in 2026: the short answer
What Inngest is and what it bills for
Inngest is a platform for running background jobs and multi-step workflows in your own code, with retries, scheduling and queueing handled for you.
What the bill meters
That design shapes the invoice. You're billed on how much work flows through it: executions, which are function runs, and steps, which are the individual units of work inside each run.
You get pushed to a higher tier by concurrency (how many runs can go at once) and retention (how long run history is kept), because both are capped per plan.
Where to find current Inngest pricing numbers
Inngest's own pricing page is where those numbers live, and that's the page to read.
Your real cost is that fee plus overage, so estimate your monthly runs and steps per run before you compare plans.
If you are running this arithmetic for your own team, see what the same workload costs on Activepieces.
Inngest plans, prices and limits
Your runs and steps per run decide the bill, because Inngest's three tiers (Free, a paid self-serve plan and Enterprise) differ less in features than in how each limit is set.
I haven't reproduced most dollar figures here because I couldn't confirm them against the live pricing page in November 2026. Take your own monthly estimate to that page and check it against the shape below.
The table shows how each limit behaves on each tier.
| Plan | Monthly price | Included executions | Concurrent steps | Trace retention | Users | Support | Overage rate |
|---|---|---|---|---|---|---|---|
| Paid | Flat monthly fee | Larger allowance | Higher ceiling | Longer window | More seats | Standard | Metered per unit past the allowance |
| Enterprise | Set by contract | Negotiated | Negotiated | Negotiated | Negotiated | Dedicated | Negotiated |
Plan limits checked against inngest.com on November 8, 2026.
You can't price Enterprise from a page, because every cell in its row is negotiated.
Inngest Free, paid and Enterprise plan differences
Moving from Free to paid mostly buys headroom. The execution allowance grows, concurrency rises, traces stay searchable longer, and overage replaces a hard stop.
Small production app monthly costs
Once volume grows, the usage fees, not the sticker price, decide whether the bill is cheap or expensive.
As long as a side project's executions and steps stay inside the free allowance, its bill is zero, so the only question is whether you'll outgrow it.
Once volume grows, the usage fees, not the sticker price, decide whether the bill is cheap or expensive.
Count steps, not function calls. A workflow with several steps burns through the allowance several times faster than the number of triggers suggests.
Small SaaS: base price plus overage
Once real customers arrive, you move to the paid plan and the arithmetic changes. Divide the monthly bill by the runs you actually execute.
That cost per run is the number to track, because the base fee is spread over a fixed pool of included executions, and every run past that pool is billed at an overage rate.
Budget for the busiest day, not the average one. A bursty workload pays for headroom even in a month with modest totals, because extra concurrency is a separate line.
Busy app: where the next plan is cheaper
At high volume, overage becomes the largest part of the bill, and the per-execution rate matters more than the base. The next plan up is cheaper once its higher base fee is smaller than the overage you would otherwise pay on the same executions.
Find that point with your own step counts: multiply monthly executions by the overage rate, add concurrency charges, and compare the total to the next tier's base.
Hidden Inngest costs and limits
If you only read the published prices, you miss the meter: every step, retry and seat adds usage or cost that the plan sticker never shows. The limits below are the ones that move a real bill.
Steps, retries and fan-out multiply usage
Count one execution per step plus one for the run itself, as Inngest's cost guidance does.
Two steps bill as 3 executions, three as 4, four as 5, five as 6, six as 7 and seven as 8, making a seven-step pipeline cost as much as eight separate runs.
Retries re-execute a failed step, and fan-out creates one step per branch, so a flaky API or a 50-item batch can cost more than the happy path suggests.
At 5 concurrent steps, a burst of 20 jobs queues instead of running, so users wait. Free allows 5 and Pro allows 100, and that delay can push you onto Pro before your execution count does.
Inngest retention, payload size and seat limits
When you only get 24 hours of trace history, a failure that surfaces on Monday may be gone from the traces by Tuesday, leaving no trace data for incident post-mortems. Seven days is the next tier's window.
Seats at $10 each scale with every engineer who needs to debug a run, so a ten-person team pays $100.
Your functions still run on your own compute, even though Inngest orchestrates the work. Each step you add also adds time on that bill, so price both together.
Inngest against Trigger.dev, Temporal and QStash
When your runs are short and have few steps, Inngest may be cheapest; the alternatives can win when you pay for something else, such as compute time, workflow actions or plain messages. Each prices a different unit, so the same job costs different amounts.
Comparison table of the options
The table shows what each product bills for and where it can be self-hosted. The billed unit, not the entry price, tells you how your bill will grow.
| Inngest | Trigger.dev | Temporal Cloud | QStash | |
|---|---|---|---|---|
| Entry paid price | Tiered monthly plan | Tiered monthly plan | Usage-based, with plan tiers | Pay-as-you-go option |
| Free allowance | Yes, capped | Yes, capped | Trial-style entry | Yes, capped |
| Billed unit | Executions and steps | Run count plus compute time | Workflow actions | Messages |
| Concurrency limits | Capped per plan | Capped per plan | Set by namespace capacity | Capped per plan |
| Self-hosting | Yes | Yes | Yes (open-source server) | No, managed only |
| Cost at 1M runs | Driven by steps per run | Driven by run duration | Driven by actions per workflow | Driven by messages per run |
Count your steps, seconds or actions per run first, then multiply by a million. That's the only comparison that holds up.
When an Inngest alternative is cheaper
When runs are long and compute-heavy, pick Trigger.dev, since you're billed for the time they use anyway. Pick QStash when a job is one HTTP call with a retry, because paying for step orchestration you never use is waste.
Pick Temporal Cloud when workflows run for days and need strict guarantees, and your team can carry its learning curve.
If your "background jobs" are really business workflows (webhooks, CRM updates, email) that non-developers maintain, Activepieces, an MIT-licensed core with 747 integrations, bills those by the run rather than by the step, though it doesn't replace Inngest's code-first durable functions.
Zapier's pricing page bills per task and Make's bills per module, which taxes the builder for splitting work into smaller, more reliable steps.
Self-hosting swaps the per-run meter for servers and an engineer's on-call hours. It pays off when volume is high and steady. At low volume, the managed free tier is almost always cheaper.
Worth checking against a plan that does not meter every step: one credit covers a whole run on Activepieces.
How to keep an Inngest bill from growing
Past the free tier, you keep the bill flat by shrinking what gets metered. That means fewer steps per run, fewer runs per event, and a cap on how much work starts at once.
How to cut billable Inngest steps
Split a function into seven steps and it costs roughly seven times what the same logic costs as one, because every step is a line item.
Keep a step boundary only where a retry would otherwise redo expensive or non-repeatable work, such as a payment call, and merge the cheap, idempotent bits around it.
Batching helps in the same way: one run that handles a group of events pays for its steps once instead of once per event.
Fan-out deserves the same audit, because every event you send to several functions multiplies runs, so trim the subscribers that no longer earn their keep.
Throttle before you pay for overage
When someone saves one document ten times, that is a burst of near-identical events, and debouncing collapses them into one run.
Rate limiting drops or delays repeats from a noisy source. A concurrency limit stops a spike from running everything at once, so you queue rather than upgrade.
Inngest also now runs up to 3x your concurrency limit for one hour a month, which means one surprise spike a month won't build a backlog. Treat that as a safety net, not capacity, and don't size your plan around it.
Put an alert below your plan's execution and step limits so you learn about growth before the invoice does.
Change plans when overage would cost more than the upgrade, and look at other tools only if the limits still don't fit after trimming.
How to prepare for Inngest selection
Run the checklist below in order, because each step produces the number the next one needs.
How to pull your Inngest usage numbers
Start with your own logs, not an estimate from memory. Count the function runs you trigger in a typical month, then count the steps inside each run, since steps are what the bill meters alongside runs.
Then find your retry rate: every retried step is billed work you didn't plan for, so a flaky downstream API quietly multiplies your count. The result is your real monthly volume, and it'll be higher than the clean figure in your head.
- Count monthly runs and steps.
- Multiply by your retry rate.
- Price the result against the plan table.
- Price one alternative.
- Recheck the pricing page for changes since November 2026.
Price two options
Run the retry-adjusted total through the plan table, including the concurrency and retention limits, not only the included runs. A plan that covers your volume but caps concurrency below your peak will throttle you, and that's a cost even when no invoice line shows it.
Work out the overage on your current tier and the flat cost of the next one up. Whichever is lower wins, and the answer can flip as your volume grows.
Then do the same arithmetic for one alternative tool. One is enough. The aim is a comparison on identical volume, not a survey of the market.
How to recheck Inngest pricing before committing
Pricing pages change, and your arithmetic is only as current as the page you copied it from. Before you commit, reopen the plan table and check it for anything that has changed since November 2026: included volumes, concurrency caps, retention windows, overage rates.
If any has moved, redo steps three and four. It takes minutes, and it's cheaper than discovering the change on an invoice.
What Activepieces does about this
The problem in this article is that Inngest's bill follows steps, retries and fan-out, so the number you budget on is not the number you pay. Activepieces changes the unit. Its published pricing meters the flow run at 1 credit and nothing inside it.
A seven-step flow that bills as 8 executions on Inngest is one credit, and so is the same flow after you add retries or branches. Step count stops being the thing you have to optimise.
That only helps for some workloads. Activepieces is not a replacement for Inngest's code-first durable functions, and if your busiest function is long-running application logic, the comparison doesn't apply. It fits where the "background jobs" are really business workflows: webhooks, CRM updates, email, approvals.
Those are often the ones that fan out most and that non-developers end up maintaining. There are 747 integrations available for that kind of work. MoneyGram, Moneypenny, Alan and FundingSocieties run it in production.
The core is MIT-licensed, so the self-hosting option from the previous section is available without a licence negotiation. You still swap the per-run meter for servers and on-call hours, and that trade pays off only at high, steady volume.
At low volume, a managed free tier is usually cheaper, whichever tool you pick.
To test this against your own workload, take the step counts you pulled from your logs and split your functions into two groups. Price the code-heavy ones on Inngest as above.
For the workflow-shaped ones, count runs only, multiply by the credit rate on the Activepieces pricing page, and compare that total with the retry-adjusted Inngest figure.
Check the concurrency and retention limits on that page too, as you would for any plan, because a low sticker price is the wrong comparison there as well.
Frequently asked questions
Is Inngest free to use? Yes, there's a free plan, and it's enough to build and test on.
It's a ceiling, not a trial: once your workload outgrows its limits on executions, concurrency or retention, the plan stops fitting. Check those limits against your real traffic before you launch, not after.
Does Inngest charge per step or per execution?
The billed unit is the execution, and steps are what multiply it. A function that fans out into many steps generates far more executions than one that does the same work in a few.
Two apps with identical user counts can therefore land on different bills. Count the steps in your busiest function and you have the real driver of your invoice.
Can I self-host Inngest? Yes. Inngest can be run on your own infrastructure as well as used as a hosted service.
Self-hosting removes the per-execution line from the invoice, but it moves the cost to servers, upgrades and whoever gets paged when the queue stalls. Price that engineer time at your own hourly rate before calling it free.
What happens if I go over my plan limits?
I wouldn't guess here, and neither should you. How overages are handled, whether by metered charges, throttling or a forced upgrade, is stated on Inngest's pricing and billing pages, and the answer differs between plans.
Read it before you launch, because a surprise at the limit is the expensive kind. If the terms are unclear, treat that as a flaw in the plan and ask in writing.
Does Inngest offer discounts for startups? I couldn't confirm a startup program from Inngest's pages, so I won't claim one.
Ask them directly and get any discount in writing, with the limits it applies to. A discount on a plan whose limits don't fit your workload is still the wrong plan.
Related reading
References
Running the numbers
See what the same workload costs here.
Free forever plan, and every paid plan self-hosts at no extra cost.
See pricing Talk to sales
