Trigger.dev pricing

About

Trigger.dev is an open-source (Apache 2.0) background-jobs and workflow-orchestration platform for developers, operated by API Hero Ltd. Engineers write long-running, durable “tasks” in TypeScript directly in their own codebase (typically a src/trigger folder), and Trigger.dev runs them on managed workers with no timeouts, no servers to manage, and built-in resilience to failure. Tasks can checkpoint and resume across waits, which makes the platform a common choice for multi-step AI agent runs, scheduled jobs, and long-running async workflows.

The platform competes with durable-execution and job-queue tooling such as Temporal, BullMQ, and the workflow layer of automation tools like n8n. Trigger.dev positions on developer ergonomics (tasks are plain code, version-controlled alongside the rest of the app) and on the fact that you can self-host the same engine you run on Trigger.dev Cloud.

Its pricing reflects a compute-platform model rather than a per-seat SaaS model: a flat monthly base plan bundles a credit allowance, and actual workload cost is metered on compute duration (per-second machine rates) plus a per-run invocation fee. For the most current information, visit Trigger.dev.

Pricing summary : base plan plus per-second compute metering

Trigger.dev runs a hybrid pricing model: a flat monthly base plan (Free $0, Hobby $10/mo, Pro $50/mo, Enterprise custom) that bundles a monthly credit allowance, on top of per-second compute metering. Compute is the primary value metric — you pay only while a task is executing, at per-second rates that depend on the machine size you select. The paid plans’ base fee doubles as the included credit balance: Hobby includes $10/mo of credits, Pro includes $50/mo of credits, and overage compute is billed at the same per-second rates once the allowance is exhausted.

Billing dimensions:

• Compute duration — per-second machine rates from $0.0000169/sec (Micro, 0.25 vCPU / 0.25 GB) up to $0.0006800/sec (Large 2x, 8 vCPU / 16 GB). Small 1x ($0.0000338/sec) is the default machine.
• Run invocations — $0.000025 per run that starts executing ($0.25 per 10,000 runs), charged on top of compute. DEV-environment runs are free.
• Concurrency — included concurrent-run ceilings (20 Free / 50 Hobby / 200+ Pro); Pro buys extra concurrency in bundles of 50 for $10/mo.
• Seats and capacity add-ons — Pro includes 25 seats then $20/mo per additional seat, plus metered add-ons for preview branches, custom dashboards, schedules and Realtime connections (each “then $10/mo per unit”).
• Concurrent Realtime connections — an included allotment per tier (10 Free / 150 Hobby / 1,000+ Pro); only Pro meters overage, at $10/mo per additional 1,000.

What makes this different: the monthly base fee is not a license — it is a prepaid credit balance against pay-as-you-go compute, so a developer with a tiny workload effectively pays only the base while heavy workloads scale linearly on per-second compute. Waiting tasks are checkpointed and do not consume compute or concurrency, so idle time in long workflows is free.

Pricing by product

Trigger.dev Cloud (base plans)

Pro plan metered add-ons (above the included ceilings)

Compute pricing (per-second machine rates)

Compute is metered per second of task execution at a rate set by the machine size you choose. You are only charged while a task is executing; the Small 1x machine is the default.

Run pricing (per-invocation)

Every run that starts executing on managed workers is charged $0.000025 per run invocation ($0.25 per 10,000 runs) on top of compute. Runs in the DEV environment are not charged. Compute beyond a paid plan’s included credits is billed at the per-second rates above; on the Free plan, tasks stop once the $5 credit allowance is spent.

Sales motions across products: PLG / self-serve for Free, Hobby and Pro (including all metered add-ons); sales-led for Enterprise.

Hidden costs : What Trigger.dev users actually pay

The headline plan prices undersell what a real production workload costs, because the base fee is a credit balance — not a cap. Once you burn the included credits, every additional second of compute and every run invocation is billed on top. The line items that surprise teams:

• Compute past the included credits. Pro’s $50/mo buys $50 of compute credits. A team running heavier machines (Medium 2x at $0.0001700/sec, Large 1x at $0.0003400/sec) or high-volume tasks blows through that quickly, and the overage is pure pay-as-you-go with no included buffer beyond the base.
• Run invocation fees stack on top of compute. At $0.000025 per run, a service doing millions of short runs pays a meaningful invocation bill independent of compute time — $0.25 per 10,000 runs means 10 million runs/mo is roughly 250 dollars in invocation fees alone, before a single second of compute.
• Per-seat overage on Pro. Pro includes 25 seats, then $20/mo per additional seat — a real cost for a larger eng org.
• Capacity add-ons. Extra concurrency ($10/mo per bundle of 50), preview branches ($10/mo each over 20), dashboards ($10/mo each over 5), schedules ($10/mo per 1,000 over 1,000) and concurrent Realtime connections ($10/mo per 1,000 over 1,000) all meter independently.
• Machine-size selection is the biggest lever. Choosing Large 2x ($0.0006800/sec) over the default Small 1x ($0.0000338/sec) is a 20x cost multiplier for the same wall-clock duration. Picking the right machine is the single largest cost decision.

The mitigants are real, though: DEV-environment runs are free, waiting tasks are checkpointed and cost nothing, and billing alerts fire at 75/90/100/200/500% of budget. A representative small workload is genuinely cheap — the pricing page’s own worked example puts a 10-second task at 100 runs/day on Small 1x at ~$1.09/mo.

Want to estimate your own Trigger.dev bill? Use the Trigger.dev pricing calculator to model your costs based on usage patterns.

Pricing evolution : Trigger.dev pricing history and changes

Trigger.dev’s pricing is inseparable from its product re-architecture. The original product was a GitHub-Actions-style workflow builder; the move to a per-second-compute meter only made sense once the engine became a true durable-execution platform.

Cadence

Tracked range: 2024–present.

Notable changes

• 2024-01 → 2024-09 — v3 reframed Trigger.dev from a workflow tool into durable functions, which is what justifies billing by compute-seconds rather than per-workflow.
• 2025-08 — v4 on Run Engine 2 added warm starts, directly reducing the compute-seconds a cold task burns (a pricing-relevant infra change even though the rate card didn’t move).
• 2026-06 — Current rate card confirmed: three published tiers as credit balances, a 7-tier per-second machine table ($0.0000169 to $0.0006800/sec), and a flat $0.000025 per-run invocation fee. No published price increases in the tracked window — the meter has been stable.
• 2026-09-11 — Included concurrent Realtime connections tripled on Hobby (50 → 150) and doubled on Pro (500+ → 1,000+), with every dollar figure on the page unchanged: $0 / $10 / $50 / Custom base fees, the same $5/$10/$50 credit allowances, the same seven-row per-second compute table, and the same $0.000025 per-run invocation fee. Because Pro’s Realtime overage rate also held at $10/mo per additional 1,000 connections, the effective price of an included connection fell by roughly half on Pro and two-thirds on Hobby — a real concession delivered entirely through the included ceiling rather than the rate card.

What’s unique : Trigger.dev’s distinctive pricing mechanics

1. The base fee IS the credit balance. Most freemium SaaS charges a subscription and meters usage separately. Trigger.dev collapses the two: your $50 Pro fee is literally $50 of compute credits. There’s no double-charge — light users pay just the base, heavy users pay the base then linear overage. This makes the entry price feel like a subscription while the economics behave like pure usage, which is unusual and buyer-friendly.

2. Waiting is free because of checkpointing. Competing durable-execution platforms often charge for the wall-clock time a workflow is “alive.” Trigger.dev snapshots a process when it waits more than 5 seconds (or awaits a subtask) and restores it later, so idle time accrues no compute and doesn’t count against concurrency. A multi-day email drip or a human-in-the-loop approval flow costs essentially nothing while it waits — a structural pricing advantage for long-running workflows.

3. Two orthogonal meters: compute-seconds AND run invocations. Trigger.dev bills both the duration of execution (machine rate × seconds) and a flat per-run fee ($0.000025). This separates “long tasks on big machines” from “millions of tiny tasks” so the price tracks the actual cost driver in each case. The machine table spans a 40x range (Micro to Large 2x), letting you tune cost to the workload rather than paying a one-size-fits-all rate.

4. Open source is the price ceiling. Because the engine is Apache 2.0 and self-hostable, the managed-cloud compute fee is implicitly bounded by “what it would cost me to run this myself.” That disciplines the rate card in a way pure-SaaS competitors don’t face.

5. The rates hold still; the included ceilings move. Because the base fee is a credit balance, Trigger.dev can’t discount the plan without also shrinking the compute it buys — so the adjustable surface is the set of non-credit capacity ceilings sitting beside it. By the 2026-09-11 capture, included concurrent Realtime connections had gone from 50 to 150 on Hobby and from 500+ to 1,000+ on Pro while $10 and $50 stayed put, and with Pro’s overage rate unchanged at $10/mo per additional 1,000 the effective price per included connection halved on Pro and fell by two-thirds on Hobby. Repricing through the entitlement rather than the rate card lets the offer improve for streaming-heavy agent frontends without disturbing the credit arithmetic everything else in the model depends on.

Strengths & weaknesses

Billing UX : spend alerts, credit balances, and self-serve add-ons

• Billing alerts — configured in the dashboard’s organization settings; standard alerts fire at 75%, 90%, 100%, 200% and 500% of the monthly budget.
• Spike alerts — separate runaway-usage detection that catches spend spikes at up to 100× normal usage.
• Included credit balance — each paid plan’s monthly base ($10 Hobby, $50 Pro) is shown as a prepaid credit balance; compute draws down against it and only overage past the allowance is billed at per-second rates.
• Usage estimator — the pricing page documents the formula (compute seconds × machine rate + per-run invocation cost × run count) and a worked example, so a developer can model a workload before running it.
• Self-serve capacity add-ons — concurrency bundles, seats, preview branches, dashboards, schedules and Realtime connections all expand from the dashboard at fixed ”+$10–$20/mo per unit” rates without a sales conversation.
• Free idle time — waiting tasks (wait.for / wait.until over 5 seconds, or parents awaiting subtasks) are checkpointed and do not accrue compute charges or count against concurrency limits.
• HIPAA BAA add-on — a signed Business Associate Agreement is available as a paid add-on, requested directly (“Request a BAA”) on paid plans.
• API rate limits with a self-serve raise path — all plans are capped at 1,500 API requests per minute; paid plans can request a higher limit, and batchTrigger() packs up to 1,000 tasks into a single API call to stay under it.
• Per-second / per-hour rate toggle — the compute rate card has a “Per sec / Per hour” switch so you can read the machine table in whichever unit matches how you model the workload.

Strategic wins : Why Trigger.dev’s pricing decisions worked

1. Pricing the actual cost driver, not a proxy

By metering compute-seconds and run invocations, Trigger.dev charges for the two things that actually cost it money to provide. There’s no value-metric mismatch — heavy users pay more, light users pay almost nothing, and the company’s margin tracks usage. This is textbook usage-based pricing: the meter aligns customer cost with customer value (a task that ran is a task that did work).

2. The credit-balance base removes adoption friction

Folding the base fee into a credit balance is a quiet but powerful win. Developers hate paying a subscription and metered usage — it feels like being charged twice. Presenting $50/mo as “$50 of compute” makes the entry price feel fair and lets a buyer start small with predictable cost, then scale linearly. It’s a smoother on-ramp than competitors who separate platform fee from usage. Related: why AI companies are moving off per-user licenses.

3. Open source as a trust and pricing anchor

Shipping the engine under Apache 2.0 with a real self-hosting path turns “you’re locking me in / you’ll gouge me later” objections into non-issues. The managed cloud has to stay priced below the all-in cost of self-hosting, which keeps the rate card honest and converts a developer audience that distrusts opaque SaaS pricing. See choosing the right usage metric for why a defensible, self-checkable meter matters.

4. Widening the entitlement instead of cutting the price

By the 2026-09-11 capture Trigger.dev had tripled Hobby’s included concurrent Realtime connections to 150 and doubled Pro’s to 1,000+, leaving $10, $50, the per-second compute table and the $0.000025 run fee exactly where they were. That delivers the commercial effect of a discount — more workload fits inside the same bill — without resetting the published price anchor or inviting every existing customer to re-open the pricing conversation. It also aims the giveaway where the demand is: Realtime connections are the streaming channel agent and long-running-task frontends hold open, so the concession lands on precisely the workloads Trigger.dev wants to win, and because connection ceilings sit outside the compute credit meter it costs infrastructure capacity rather than credits. Moving an entitlement ceiling is the cheapest competitive lever available in a credit-balance model, precisely because it leaves the published rate card untouched.

Areas to improve : Gaps in Trigger.dev’s pricing approach

1. Cost predictability for variable workloads

Two independent meters plus a 40x machine-size range make it genuinely hard to forecast a monthly bill before you run. A developer choosing the wrong machine can 20x their compute line without realizing it. Billing alerts help after the fact, but a pre-run cost estimator/budget simulator in the dashboard (beyond the worked example on the pricing page) would reduce bill-shock risk that’s common in pure compute-metered products.

2. The Free-tier hard stop

Free hard-stops at $5 of credits with no overage — tasks simply stop. That’s clean for cost control but harsh for a developer mid-experiment: there’s no graceful “spill into paid” option without committing to a plan. A small auto-top-up or pay-as-you-go-on-Free option would smooth the conversion moment. The same cliff logic sits one tier up, and the 2026-09-11 increase moved it rather than removed it: Hobby’s included concurrent Realtime connections tripled to 150, but Hobby still carries no Realtime overage rate, so the 151st connection isn’t a $10/mo add-on the way it is on Pro — it’s a jump to the $50 plan. Extending Pro’s “$10/mo per additional 1,000” overage down to Hobby would let the tier grow into its bill instead of hitting a 5× step.

3. Per-seat overage friction at scale

Pro’s $20/seat over 25 seats is real money for a larger eng org that just wants more people to view dashboards. Decoupling read-only/viewer access from billable seats (a pattern many dev tools have adopted) would remove a tax on collaboration and reduce a common pricing complaint as teams grow.

Key takeaways

1. The base fee is credits, not a license. Free $0, Hobby $10, Pro $50 each bundle an equal credit balance; you only pay more when compute exceeds it. Light workloads pay just the base.
2. Two meters drive cost: per-second compute ($0.0000169 to $0.0006800/sec by machine size) and a flat $0.000025 per-run invocation. Long tasks on big machines and high-volume tiny tasks are priced by different levers.
3. Idle is free. Checkpointed waits over 5 seconds cost no compute and don’t count against concurrency — a structural advantage for long-running and agent workflows.
4. Machine size is the dominant cost decision — a 40x spread from Micro to Large 2x, with Small 1x as the default. Right-sizing is the biggest controllable lever.
5. Open source caps the downside. Apache 2.0 + self-hosting means the managed price is anchored to do-it-yourself cost, building trust with a skeptical developer audience.

UBP implications

1. Fold the platform fee into a credit balance to kill “double-charge” objections. If you must charge a base, make it spendable. Trigger.dev’s model shows you can keep the predictability of a subscription on-ramp while behaving like pure usage underneath — a strong template for hybrid pricing. The corollary is that a spendable base can’t be discounted without shrinking what it buys, so your cheapest competitive move becomes the non-credit ceilings beside it: the 2026-09-11 Realtime-connection increase improved both paid tiers without touching a single published rate.
2. Price the real cost driver, and split meters when there’s more than one. Compute-seconds and run-count are genuinely different cost dimensions; conflating them into one metric would over- or under-charge whole classes of users. When your cost structure has two drivers, two meters can be fairer than a forced single value metric.
3. Don’t charge for idle, and let open source discipline your rate card. Checkpointing waiting work so it costs nothing makes long-running and agentic workloads economically viable — a differentiator competitors who bill wall-clock time can’t match. Pairing that with a self-hostable, open-source engine publicly caps how aggressive your managed pricing can be, which is itself a trust-building feature for developer-led adoption.

Sources

• Trigger.dev pricing page (accessed 2026-09-11) — plans, compute table, run invocation, FAQ
• Trigger.dev limits documentation (accessed 2026-09-11) — per-seat and per-bundle add-on rates, API rate limits, batch size, schedule and queue ceilings
• Trigger.dev machine presets documentation (accessed 2026-09-11) — machine vCPU/RAM specs and the default small-1x machine
• Trigger.dev blog (accessed 2026-06-16) — v3/v4 launches, $16M Series A and $3M seed funding history
• Trigger.dev documentation (accessed 2026-06-16) — task model, self-hosting, limits
• Trigger.dev official website (accessed 2026-06-16) — product positioning, API Hero Ltd. entity

Bottom line

Trigger.dev runs one of the cleaner hybrid pricing models in developer infrastructure: a flat monthly base (Free $0, Hobby $10, Pro $50, Enterprise custom) that doubles as a prepaid compute-credit balance, plus pay-as-you-go per-second compute and a flat per-run invocation fee. You only pay while tasks execute, idle waits are free, and the whole rate card is public down to the per-second machine table. The catch is predictability — two meters and a 40x machine-size range mean a real production bill takes modeling, and the Free tier hard-stops at $5 of credits. For teams running durable background jobs, scheduled work, or long-running AI agent workflows, the economics are usage-aligned and the open-source self-host path caps the lock-in risk.

Want to estimate your own Trigger.dev bill? Use the Trigger.dev pricing calculator, or compare it against other developer-infrastructure companies in the pricing blueprint.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Realtime connection allotments raised on Hobby and Pro

Sep 2026

Included concurrent Realtime connections increased from 50 to 150 on Hobby and from 500+ to 1,000+ on Pro. Plan prices ($0 / $10 / $50), the per-second compute table and the $0.000025 per-run invocation fee were unchanged, and Pro's overage rate held at $10/mo per additional 1,000 connections — so the effective cost per included connection fell by about half on Pro and two-thirds on Hobby.

Rate card in place: credit-balance tiers plus per-second compute

Jun 2026

Free $0, Hobby $10/mo, Pro $50/mo and custom Enterprise, each bundling a monthly credit allowance, sit on top of per-second machine rates ($0.0000169 to $0.0006800/sec) and a $0.000025 per-run invocation fee ($0.25 per 10,000 runs).

v4 GA on the new Run Engine

Aug 2025

v4 went GA on a rebuilt Run Engine 2 with warm starts and a revamped dashboard, improving cold-start economics for the per-second compute meter.

v3 GA with new CLI and build system

Sep 2024

v3 reached general availability with a new CLI and revised build system, cementing the code-first 'tasks live in your repo' model that the compute meter bills against.

v3 announced: durable functions, no timeouts

Jan 2024

Trigger.dev announced v3, repositioning from a GitHub-Actions-style workflow tool to durable serverless functions with no timeouts — the foundation for the current per-second-compute pricing model.