A8gent
AI Agent PlatformsDeveloper framework

Trigger.dev Pricing and Review (2026)

Open-source background jobs and long-running agent tasks, billed by the compute second.

Reviewed by A8gent
Contents
  1. Verdict
  2. What is Trigger.dev?
  3. Best for, and not for
  4. Strengths and limits
  5. Pricing
  6. What people actually build with Trigger.dev
  7. What Trigger.dev actually costs at small-business volume
  8. The gotcha: the plan price is a credit, and waiting on a model is not free
  9. What breaks in production, and how you find out
  10. What it connects to that you already run
  11. Trigger.dev alternatives: what to pick instead, and when
  12. Migration and lock-in: can you get your work out?
  13. FAQ
VerdictIs Trigger.dev worth it?

Trigger.dev is very good value for the work it is designed for and easy to misprice from the plan table. The $10 and $50 are not allowances of runs; they are compute credit, and compute is $0.0000338 a second on the default machine plus $0.000025 a run. Our reference workload of 1,000 short triage runs a month costs about 70 cents and fits inside the Free plan's $5. A thousand five-minute agent runs costs $10.17 on the default machine and $204 on the largest one. So it is worth it if you have a developer and jobs that run long, and the plan you need depends almost entirely on run length and machine size, not on how many runs you have.

What is Trigger.dev?

Trigger.dev is an open-source platform for running background jobs and long-running tasks, including AI agent runs, without managing queues or servers. You write tasks in code, deploy them, and Trigger.dev runs each one on a machine size you choose, with retries, schedules, concurrency controls and a dashboard of every run. The cloud service bills for the seconds of compute a run uses plus a small fee per run. The code is Apache 2.0 licensed and can be self-hosted.

Best for

Developers who need agent runs or jobs that last minutes or hours and want to pay for seconds used rather than servers reserved.

Not for

Non-technical teams, and anyone who wants a visual builder or a catalogue of ready-made app connectors.

Strengths

  • Per-second compute billing with every machine price published, from $0.0000169 to $0.0006800 a second
  • No maximum run duration by default, which suits long agent runs that time out elsewhere
  • Subtask waits, and explicit waits longer than 5 seconds, are not billed as compute
  • Runs in the development environment are not charged
  • Apache 2.0 licensed and self-hostable, with an active repository
  • Billing alerts at 75, 90, 100, 200 and 500 percent of a monthly budget, plus spike alerts

Limitations

  • The plan price is a usage credit, not an allowance of runs, so you have to estimate seconds to know which plan you need
  • On the Free plan tasks stop once the $5 credit is used, until you upgrade
  • Machine size multiplies the bill: the largest machine costs 20 times the default per second
  • Log retention is 1 day on Free and 7 days on Hobby
  • Self-hosting loses warm starts, auto-scaling, checkpoints and dedicated support
  • It is a developer tool with no connector catalogue, so every integration is code you write

Trigger.dev pricing

Trigger.dev charges for compute by the second, at a rate set by the machine size, plus $0.000025 for each run. Plans are a monthly fee that includes the same amount in usage credit: Free includes $5, Hobby is $10 with $10, Pro is $50 with $50. Plans also set concurrency, team size, schedules and log retention. On paid plans tasks keep running past the credit and the extra is billed at the same rates.

Trigger.dev pricing tiers
PlanPriceWhat you get
Free$0$5 of usage credit a month, 20 concurrent runs, 5 team members, 10 schedules, 1 day of logs. Tasks stop when the credit is used until you upgrade
Hobby$10/mo$10 of usage credit, 50 concurrent runs, 5 team members, 100 schedules, 7 days of logs, 5 preview branches
Pro$50/mo$50 of usage credit, 200 concurrent runs then $10 a month per extra 50, 25 team members then $20 a seat, 1,000 schedules, 30 days of logs, dedicated Slack support
EnterpriseCustomCustom limits and discounts, custom log retention, role-based access control, single sign-on, SOC 2 report
Compute$0.0000338/secSmall 1x, the default machine (0.5 vCPU, 0.5 GB). Micro is $0.0000169; Small 2x $0.0000675; Medium 1x $0.0000850; Medium 2x $0.0001700; Large 1x $0.0003400; Large 2x $0.0006800
Run fee$0.000025/run$0.25 per 10,000 runs, charged on top of compute. A HIPAA BAA is a $500 a month add-on on Hobby and Pro

Pricing reflects public plans as of November 17, 2026 and can change. Check Trigger.dev for the latest.

What people actually build with Trigger.dev

Trigger.dev solves one specific problem: work that takes too long, fails too often or runs too unpredictably to live inside a web request. Agent runs are the current headline example, but the shape is older than agents.

The builds that fit

A long-running agent task. An agent that researches a company, reads a dozen pages and writes a brief may run for several minutes. Trigger.dev has no maximum run duration by default, so the task simply runs to completion, with retries if a step fails.

Inbox triage at our reference volume. A scheduled task pulls new messages, calls a model once per item to classify and extract, and files the result. A thousand short runs a month is well inside the Free plan's credit.

Document and media processing. Converting, transcribing or summarising files is bursty and memory-hungry. You pick a larger machine for that one task and pay its higher rate only for the seconds it runs.

Scheduled jobs that used to be cron entries. Nightly syncs, weekly reports and reminder runs get a run history, alerts and retries. Free allows 10 schedules per project, Hobby 100 and Pro 1,000.

Fan-out work. One trigger starts hundreds of subtasks and waits for them. Time spent waiting on subtasks does not count toward compute, and a batch call accepts up to 1,000 items.

What it is genuinely bad at

Anything a non-programmer needs to build or change. There is no canvas and no connector catalogue. Reaching your CRM means writing the API call. It is also not an agent framework: it runs your agent code reliably, but the reasoning, prompts and tools come from you or from a library you choose. A team hoping Trigger.dev will tell it how to build an agent has bought the wrong layer.

Bottom line: Trigger.dev is for developers whose agent runs or jobs last longer than a web request should, and it offers nothing to a team with no one who writes code.

What Trigger.dev actually costs at small-business volume

Two published rates make up every bill, both read off trigger.dev/pricing on 17 November 2026. Compute is charged per second at a rate set by machine size; the default, Small 1x with half a vCPU and half a gigabyte of memory, is $0.0000338 a second. Each run also costs $0.000025, which is $0.25 per 10,000 runs.

Take our reference workload: 1,000 triage runs a month, one model call each. Assume each run takes 20 seconds end to end, which is our assumption, not a measurement. Compute is 1,000 times 20 times $0.0000338, which is $0.676. The run fee is 1,000 times $0.000025, which is $0.025. Total: about $0.70 a month. That is inside the Free plan's $5 credit with room for six times the volume.

Trigger.dev's own example on the pricing page checks out the same way: a 10-second task running 100 times a day on Small 1x. 10 times 100 times 30 times $0.0000338 is $1.014, plus 3,000 runs at $0.000025 is $0.075, so $1.09 a month, the figure the page gives.

Now change one thing. Make each run a five-minute agent task instead of a 20-second classification. 1,000 times 300 seconds times $0.0000338 is $10.14, plus $0.025 of run fees, so $10.17. That no longer fits Free, where tasks stop at $5, and it uses the whole of Hobby's $10 credit plus 17 cents. Same number of runs, fourteen times the bill, and a different plan.

The model itself is not in any of this. Trigger.dev runs your code; the tokens are billed by your model provider.

Trigger.dev cost for 1,000 runs a month at different run lengths and machine sizes. Rates from trigger.dev/pricing on 17 November 2026. Run lengths are assumptions; model tokens are not included.
ScenarioComputeRun feesMonthly totalCheapest plan that covers it
20-second run, Small 1x ($0.0000338/sec)20,000 sec = $0.68$0.025$0.70Free ($5 credit)
5-minute run, Small 1x300,000 sec = $10.14$0.025$10.17Hobby: $10 plus $0.17 of extra usage
5-minute run, Medium 1x ($0.0000850/sec)300,000 sec = $25.50$0.025$25.53Hobby: $10 plus $15.53, or Pro at $50
5-minute run, Large 2x ($0.0006800/sec)300,000 sec = $204.00$0.025$204.03Pro: $50 plus $154.03
Vendor's own example: 10 sec, 100 times a day30,000 sec = $1.01$0.075$1.09Free

What the $5, $10 and $50 actually buy

Because the plan price is a compute credit, the useful question is how many seconds it covers. On the default Small 1x machine, $5 divided by $0.0000338 is 147,929 seconds, about 41 hours of running time. Hobby's $10 is about 82 hours. Pro's $50 is about 411 hours.

On the largest machine, Large 2x at $0.0006800 a second, the same $5 buys 7,353 seconds, which is two hours. That machine costs 20 times the default per second. So the credit is not small or large in itself; it is 41 hours of a small machine or 2 hours of a big one.

What the plans change besides credit is headroom. Concurrency is 20 runs on Free, 50 on Hobby and 200 on Pro. Log retention is 1, 7 and 30 days. Team members are 5, 5 and 25. On Pro, extra concurrency is $10 a month per 50 runs and extra seats are $20 each, so a 30-person team on Pro is $50 plus 5 times $20, which is $150 before usage.

Bottom line: A thousand 20-second runs on Trigger.dev cost about 70 cents and a thousand five-minute runs cost $10.17 on the default machine, so run length and machine size decide the plan, not run count.

The gotcha: the plan price is a credit, and waiting on a model is not free

The first misreading is treating the plans like the tiers on a task-based automation tool. On those, $10 buys a number of tasks. Here, $10 is $10 of compute at published per-second rates, and the plan is really a bundle of limits with a prepaid balance attached. Two teams on Hobby can have bills that differ tenfold.

The second is subtler and matters most for agents. The pricing page says time spent waiting on subtasks does not count toward compute, and that waits longer than 5 seconds using the platform's own wait functions also do not count. Those are the two exemptions it lists. An agent run that makes a model call and awaits the HTTP response is doing neither. It is a running machine waiting on the network, and our reading of the page is that you should plan for those seconds to be billed. Since most of an agent's wall-clock time is spent waiting for a model, most of an agent run's duration is billable compute. That is why the five-minute example above costs what it does even though the machine is idle for most of it.

The practical lever is machine size. A task that mostly waits on API calls needs almost no CPU or memory, so run it on the default or on Micro at $0.0000169 a second, which halves the bill. Reserve the larger machines for tasks that truly need memory, such as parsing large files, and set the machine per task rather than for the whole project.

The third is the Free plan's hard stop. The pricing page says that once the $5 in credits is used, you must upgrade to keep running tasks. On paid plans tasks keep running and the extra is billed. A production workload on Free therefore fails closed at an unpredictable point in the month. Free is for development, and development runs are not charged anyway.

Finally, watch the add-ons on Pro, which are priced per unit a month: $10 per extra 50 concurrent runs, $20 per seat beyond 25, $10 per 1,000 schedules beyond the first 1,000, and $10 for each preview branch beyond 20. The HIPAA BAA is $500 a month on Hobby and Pro, which is fifty times the Hobby plan itself.

Bottom line: Trigger.dev exempts subtask waits and explicit waits over 5 seconds from billing, but an agent awaiting a model response is neither, so run those tasks on the smallest machine.

What breaks in production, and how you find out

The limit you meet first is concurrency. Production allows 20 concurrent runs on Free, 50 on Hobby and 200 on Pro, per environment. When the limit is reached, further runs queue rather than fail. That is the kinder failure, and it is also the quiet one: nothing errors, work just arrives late. The documented maximum time a run can wait in the queue on the cloud is 14 days, so a badly under-provisioned project can accumulate a very long backlog before anything is dropped. Alert on queue depth and on run start delay, not only on failures.

The second is log retention, which is easy to overlook until the day you need it. Free keeps logs for 1 day and Hobby for 7. If a customer reports a problem from last week and you are on Free, the evidence is gone. For anything a business depends on, 30 days on Pro is the realistic floor, or export what you need elsewhere.

Third, payload sizes. The documentation gives a 3 MB maximum for a single trigger payload and 10 MB for task output. An agent that passes whole documents between tasks will hit this. Pass a reference to stored data instead of the data.

Fourth, runaway cost. With no maximum duration by default, a task stuck in a loop runs, and bills, until something stops it. The documentation lets you set a maximum duration per project, per task or per run. Set one on every agent task. The billing alerts at 75, 90, 100, 200 and 500 percent of a monthly budget are useful but they tell you after the money is spent.

Rate limits are 1,500 API requests a minute on all plans, and an organisation is limited to 10 projects on every tier.

Self-hosting, honestly

The code is Apache 2.0 and the repository is plainly active: the GitHub API on 17 November 2026 showed 16,776 stars, 270 open issues and a push that same day. Self-hosting is offered with Docker Compose and Kubernetes guides. The documentation is direct about the trade: self-hosted installs do not get warm starts, auto-scaling, checkpoints or dedicated support, and you assume all responsibility for security, uptime and data integrity. The missing checkpoints matter for cost, because on the cloud they are what makes long waits cheap. For a small business the cloud's per-second pricing is almost always less than the staff time to run the platform yourself.

Bottom line: On Trigger.dev the production risks are queued runs arriving late and a looping task billing by the second, so alert on queue delay and set a maximum duration on every task.

What it connects to that you already run

Trigger.dev's integration model is your code. A task is a function, and inside it you call whatever you need: your database, your CRM's API, a model provider, an email service. Anything with a client library or an HTTP API is reachable, and nothing is reachable without writing the call. There is no catalogue of pre-built business connectors, and that is a deliberate difference from tools such as n8n or Zapier.

For agent work this is mostly an advantage. You are not limited to the models or tools a vendor has wrapped. You can use an agent framework such as Mastra, LangGraph or the OpenAI Agents SDK inside a task and let Trigger.dev provide the durability around it: retries, schedules, concurrency limits and a record of each run.

It fits into an existing application rather than replacing one. Tasks are triggered from your own backend, on a schedule, or in batches of up to 1,000. There are separate development, preview and production environments, and preview branches on paid plans, so changes to tasks go through the same review process as the rest of your code. A realtime feature lets a front end subscribe to run progress, with 10 concurrent connections on Free and more on paid plans.

For a business that also runs a no-code automation platform, the two sit together comfortably: the automation platform handles the simple connector-to-connector flows that non-developers maintain, and calls a Trigger.dev task over HTTP for the long or heavy step it cannot do itself.

Bottom line: Everything Trigger.dev connects to is reached by code inside a task, which removes vendor limits on models and tools and requires a developer for every integration.

Trigger.dev alternatives: what to pick instead, and when

First decide whether you need a developer tool at all. If nobody writes code, pick n8n or Make.com and stop here.

If your team does write code, the choice is about how you want to pay for compute. Trigger.dev bills seconds used. Windmill sells reserved workers, where runs are unlimited and a quiet month costs the same as a busy one, which wins when volume is high and steady. Pipedream bills credits defined as compute time and comes with a large connector catalogue, which suits developers who want pre-built app integrations as well as code.

Inngest is the closest like-for-like alternative, and we read its pricing page on the same day. It bills executions rather than seconds: the Free plan includes 50,000 a month and Pro starts at $99 a month with 1 million included. Its page says an execution is metered per function run and per step inside that run, so a function with five steps uses six executions. That model is cheaper for long runs with few steps and dearer for short runs with many.

Amazon Bedrock AgentCore is the choice if you are already on AWS and want an agent-specific runtime with identity, memory and tool gateways alongside. And if you want the framework and the hosting from one vendor, Mastra's platform is the nearest match in TypeScript.

Alternatives for the reference workload of 1,000 runs a month. Trigger.dev, Inngest, Mastra and AgentCore figures read on 17 November 2026; Windmill, Pipedream and n8n rows cite this directory's August 2026 reviews.
ToolBilling unitAt 1,000 runs a monthWho it suitsDoes better than Trigger.dev
Trigger.devCompute second plus a per-run feeAbout $0.70 for 20-second runs; inside the Free creditDevelopers with long or bursty jobsNo duration cap; pay only for seconds used
InngestExecution: one per run and one per step6,000 executions for 5-step runs; inside the 50,000 freeTeams whose runs are long but have few stepsCost does not grow with how long a run waits
WindmillSeats and reserved workers; runs unlimited$0 self-hosted plus a server (August review)High, steady volumeFlat cost regardless of volume
PipedreamCredit defined as compute timeFree tier covered this volume (August review)Developers wanting connectors and codePre-built app integrations
Mastra platformPlan plus memory, vCPU and event overageInside the Free allowances for short runsTypeScript teams wanting framework and hosting togetherAgent framework and observability included
Amazon Bedrock AgentCorevCPU-hour and GB-hour, per secondAbout $6.70 for 1,000 ten-minute sessions on AWS's example profileTeams already on AWSCPU is not billed during I/O wait
n8nExecution (whole workflow run)EUR 20 a month Starter covered 2,500 executions (August review)Mixed teams wanting a visual builderUsable by non-developers

Bottom line: Choose Trigger.dev when runs are long and irregular, Inngest when runs have few steps, and reserved workers when volume is high enough that unlimited runs beat per-second billing.

Migration and lock-in: can you get your work out?

Trigger.dev's lock-in is low and, unusually, you have two exits. The first is the ordinary one: your tasks are functions in your own repository, and the business logic inside them, the API calls, the prompts and the data handling, is plain code that runs anywhere. What is specific to Trigger.dev is the wrapper: how a task is defined, triggered, retried and made to wait.

The second exit is self-hosting. Because the platform is Apache 2.0, if the cloud service's pricing or direction changed you could run the same software yourself without rewriting anything. The documentation is clear that you would give up warm starts, auto-scaling, checkpoints and dedicated support, and take on all operational responsibility, so it is an escape hatch rather than a free lunch. But it exists, and it does not depend on the vendor's cooperation.

What you would rebuild on a move to a different orchestrator is the orchestration: schedules, retry policies, concurrency settings, the fan-out and wait patterns. That is configuration and glue rather than logic, and how much there is depends on how heavily you used platform-specific features. A codebase that keeps the work in ordinary functions and uses Trigger.dev only at the edges moves in days.

Commercially there is nothing to unwind on Free, Hobby or Pro: they are monthly, and the credit is used or it is not. Run history and logs are the one thing that stays behind, and with retention of 1 to 30 days there is little of it. If you need an audit trail, write your own records from inside the task to a store you own.

Bottom line: Your task logic is ordinary code and the platform is Apache 2.0, so you can leave Trigger.dev's cloud either for another orchestrator or for your own copy of the same software.

Trigger.dev FAQ

How much does Trigger.dev cost?

Plans are $0 (Free), $10 a month (Hobby) and $50 a month (Pro), each including the same amount in usage credit, with Free including $5. Usage is $0.0000338 a second on the default machine plus $0.000025 a run, as published on 17 November 2026. Enterprise is custom.

What does one run cost?

The run fee is $0.000025, plus compute for however long it runs. A 20-second run on the default Small 1x machine is 20 times $0.0000338, which is $0.000676, plus the fee, so about $0.0007. A five-minute run on the same machine is about $0.0102.

Is Trigger.dev free?

There is a Free plan with $5 of usage credit a month, 20 concurrent runs and 1 day of log retention. Once the credit is used, tasks stop until you upgrade. Runs in the development environment are not charged. The software is also open source under Apache 2.0 and can be self-hosted.

Do I pay while a task is waiting?

Not while it waits on subtasks, and not during waits longer than 5 seconds made with the platform's wait functions. Those are the exemptions the pricing page lists. A task that is simply awaiting a network response, such as a model call, is still a running machine, so plan for that time to be billed.

How long can a task run?

There is no maximum duration by default. You can set one per project, per task or per run, and for agent tasks you should, because a looping task is billed by the second until it stops.

What happens when I use up the plan's credit?

On Free, tasks stop and you must upgrade to continue. On Hobby and Pro, tasks keep running and the additional compute is billed at the same published rates.

Which machine size should I use?

The default Small 1x (0.5 vCPU, 0.5 GB) at $0.0000338 a second suits tasks that mostly wait on API calls. Micro is half that price. The largest, Large 2x with 8 vCPU and 16 GB, is $0.0006800 a second, 20 times the default, so use large machines only for the tasks that need the memory.

Can I self-host Trigger.dev?

Yes, with Docker Compose or Kubernetes. The documentation says self-hosted installs lack warm starts, auto-scaling, checkpoints and dedicated support, and that you take on responsibility for security, uptime and data integrity.

Is there a HIPAA option?

A HIPAA BAA is listed as a $500 a month add-on on the Hobby and Pro plans, and as an add-on without a listed price on Enterprise.

Looking at alternatives? Trigger.dev is infrastructure for developers who already have code to run. Autonoly is a managed service for businesses that have a task and nobody to write that code. If your team ships TypeScript and wants durable long-running jobs, Trigger.dev is a strong and inexpensive choice. If nobody on the team writes code, the per-second price is irrelevant because the cost is the developer. See the Autonoly review.