Inngest Pricing 2026: What You Actually Pay Per Step

Quick answer (July 2026): Inngest is free up to 50,000 step-executions a month, then moves to the Pro plan at $99/mo, which includes 1 million executions, 100 concurrent steps, and 5 GB of trace data. Overages are $50 per additional 1 million executions and $25 per additional 25 concurrent steps. The number that decides your bill is not how many jobs you run, it is how many steps each job has. Inngest meters every step, not every job, so a three-step workflow run 100,000 times and a 30-step workflow run 10,000 times cost the same: 300,000 executions either way.

That single fact is why two teams running "the same" background jobs get bills that differ by 10x. Below are Inngest's real 2026 rates, three worked 30-day bills, the two meters that actually spike, and an honest read on when a step-metered platform is worth it versus Trigger.dev or running your own queue.

Inngest pricing in 2026: the plans

Rates below are from Inngest's pricing page (July 2026).

Two details most write-ups skip. First, the Pro plan bundles 15 seats, then charges $10 per additional user. Second, trace (span) data is its own line item at $3/GB over the 5 GB allowance, which matters for high-step workflows because every step emits a span.

What counts as an execution

An execution is one step, not one function run. If your sendOnboarding function has six steps (validate, create record, send email, wait a day, send nudge, tag user), one run bills six executions. A wait or sleep step still counts. This is the whole game, so price your workload in steps:

• Steps per run, times runs per month, equals executions per month.
• Fan-out multiplies it: a step that fans out to 100 child runs of four steps each is roughly 400 executions, not one.

Three real 30-day bills (2026 rates)

Bill 1, the side project: $0. A newsletter app runs one three-step job (fetch, render, send) 12,000 times a month. That is 36,000 executions, under the 50,000 free cap, peak concurrency well below 5. You pay nothing, and you should not overthink it.

Bill 2, the growing SaaS: $99. An onboarding workflow of six steps fires for 8,000 signups (48,000 executions), a two-step daily digest runs for 3,000 users across 30 days (180,000), and assorted five-step webhooks add another 100,000. Total is about 328,000 executions a month. That clears the free tier, so you are on Pro, but 328,000 sits comfortably inside the 1 million included and peak concurrency stays under 100. Flat $99, nothing on top.

Bill 3, the AI workflow app: about $320. Each agent run is a 20-step durable workflow with retries and fan-out, run 100,000 times a month: 2,000,000 executions. Pro includes 1 million, so the extra 1 million is $50. These runs are long-lived, so peak concurrency hits 250: 100 included plus 150 over, billed as six blocks of 25 at $25, is $150. The 20-step traces push span data to roughly 12 GB, so 7 GB over the allowance at $3 is $21. Total: $99 + $50 + $150 + $21, about $320/mo, before any extra seats.

Notice what moved the needle in Bill 3. It was not the execution overage ($50). It was concurrency ($150).

The two meters that spike a bill

1. Step count. Long workflows are expensive workflows. Collapsing a six-step function to three (by batching work inside a single step) halves its execution cost. Before you scale a workflow, count its steps.
2. Concurrency. Quick jobs finish in milliseconds and never touch the 100-concurrent ceiling. Long-running work (AI calls, video, scraping, anything with a wait) holds concurrency slots open, and at $25 per 25 over 100 it can quietly outgrow your execution cost, exactly as it did in Bill 3.

Trace data is a distant third, and seats a fourth. If your bill surprised you, it is almost always one of the first two.

Inngest vs Trigger.dev: different meters, different winners

The honest comparison is not "which is cheaper," it is "which meter matches your workload." Inngest bills per step-execution. Trigger.dev bills per run plus compute-seconds (Trigger.dev pricing, July 2026): its Pro plan is $50/mo with $50 of credits, runs are $0.25 per 10,000 invocations, and compute is billed by the second per machine size.

Map your busiest workflow onto the table before you pick. A short many-step workflow that looks cheap on Inngest's free tier can flip once you cross into Pro, and a long-running task that looks fine on Trigger.dev's credits can flip once compute-seconds add up.

Build versus buy: when to run your own queue

Inngest and Trigger.dev both sell durability and observability, the retries, the step state, the traces, so you do not build a state machine by hand. The build-it-yourself path is a queue like BullMQ on Redis, with a worker you host on Railway or similar, plus Upstash's QStash for serverless scheduling. That stack has no per-step meter: cost is flat infrastructure plus your engineering time on retries, idempotency, and dead-letter handling.

The crossover is honest and workload-dependent:

• Predictable, high-volume, simple jobs: self-hosting usually wins. A flat $20 to $50 of Redis and a worker beats a metered platform once execution counts get large.
• Durable multi-step workflows with retries and fan-out: the managed step-meter is often worth it, right up until step volume explodes, at which point you re-run the math.
• Heavy, mission-critical orchestration: teams at that scale tend to look at Temporal, which is a different (and heavier) commitment than either Inngest or Trigger.dev.

There is no universal answer. There is only your step count, your concurrency profile, and how much of your own on-call time a managed platform actually buys back.

The move

Price the workload in steps and concurrency before you commit, not after the first surprise invoice. If your jobs are short and predictable, Inngest's free tier and a self-hosted queue will both carry you a long way. If your jobs are long-running or fan out heavily, model the concurrency line specifically, because on the AI-workload profile it, not the execution overage, is what sets the bill.

Math check: Inngest bills per step, so executions equal steps-per-run times runs-per-month; a 20-step workflow is 20x the execution cost of a one-step job at the same run count, and above 100 concurrent steps you add $25 for every 25.