
Trigger.dev Coupon: Free Plan
Open-source background jobs framework for TypeScript with long-running tasks.
Premium: $79/year for unlimited deals
Already have an account? Log in
Deal Highlights
Our Trigger.dev listing: the Free Plan
Offer: Free Plan. Our listing sets no requirements, there is no promo code. To use it, go to trigger.dev and create a free account.
We checked these plans and prices against Trigger.dev's official pricing and help pages in November 2026.
Trigger.dev is a platform for background tasks written in TypeScript. You write a task as an ordinary async function in a trigger folder in your own repo, deploy it, and Trigger.dev runs it on its managed workers with retries, queues, schedules and a run dashboard. Tasks have no timeouts. The code is open source under the Apache 2.0 license.
The Free Plan in our listing is Trigger.dev's public Free tier. Anyone can sign up for it at $0 with no credit card, and our listing adds nothing to it. Free is a dollar credit, not a run count, and we explain what the credit buys below.
The Free plan is $5 of credit, not a number of runs
Trigger.dev bills usage in two parts. The first is compute: the seconds your task executes, priced by machine size. The second is a per-run invocation fee of $0.000025, which is $0.25 per 10,000 runs. Runs in the DEV environment are not charged for.
The Free plan gives you $5 of credit every month. Its FAQ says that once the credits are used, you need to upgrade to keep running tasks. Paid plans keep running and bill past the included credit at the usage rates. So Free is a hard ceiling, and the ceiling is set in dollars.
What Free lists, per the pricing page:
- $5 a month in credits
- 20 concurrent runs in production
- Unlimited tasks
- 5 team members
- Dev and Prod environments
- Custom dashboards
- 10 schedules
- 1 day of log retention and a 1 day query period
- Community support
- 1 alert destination
- 10 concurrent Realtime connections
Compute rates by machine size
Trigger.dev's pricing page publishes a per-second price for each machine. The default machine is Small 1x. You can set the machine per task or per trigger.
| Machine | vCPU | RAM (GB) | Cost per second | Cost per hour (our math) |
|---|---|---|---|---|
| Micro | 0.25 | 0.25 | $0.0000169 | $0.0608 |
| Small 1x (default) | 0.5 | 0.5 | $0.0000338 | $0.1217 |
| Small 2x | 1 | 1 | $0.0000675 | $0.2430 |
| Medium 1x | 1 | 2 | $0.0000850 | $0.3060 |
| Medium 2x | 2 | 4 | $0.0001700 | $0.6120 |
| Large 1x | 4 | 8 | $0.0003400 | $1.2240 |
| Large 2x | 8 | 16 | $0.0006800 | $2.4480 |
The docs list 10 GB of disk on every preset. The hourly column is the per-second price times 3,600. We computed it, the page does not print it.
Translate the $5 credit into machine time. On Small 1x it buys about 41 hours of execution a month ($5 / $0.12168). On Micro it is about 82 hours. On Large 2x it is about 2 hours. That is before any invocation fees.
Waiting is free
The pricing FAQ says that when a parent task triggers a subtask and waits, the parent is checkpointed and does not count toward compute. A wait.for or wait.until longer than 5 seconds is also checkpointed and costs no compute. Waiting tasks also do not count against your concurrency limit, which applies only while code is executing. That matters for an email sequence that sleeps for three days between steps: the sleeping costs nothing, and only the seconds of actual work are billed.
Hobby $10, Pro $50: the fee is also the credit
| Plan | Monthly price | Credit included | Concurrent runs (prod) | Team members | Schedules | Log retention |
|---|---|---|---|---|---|---|
| Free | $0 | $5 | 20 | 5 | 10 | 1 day |
| Hobby | $10 | $10 | 50 | 5 | 100 | 7 days |
| Pro | $50 | $50 | 200+ | 25+ | 1,000+ | 30 days |
| Enterprise | Custom | Custom | Custom | Custom | Custom | Custom |
No annual price is listed. Hobby lists "$10 / month credits included" and Pro lists "$50 / month credits included", so the base fee comes back as usage credit. On a paid plan you pay the fee, and the first dollars of compute and invocations are covered by it.
Beyond Hobby, the Pro plan sells add-ons:
- 50 more concurrent runs: $10 a month
- Team members beyond 25: $20 a month per seat
- Preview branches beyond 20: $10 a month per branch
- Custom dashboards beyond 5: $10 a month per dashboard
- 1,000 more schedules: $10 a month
- 1,000 more concurrent Realtime connections: $10 a month
Hobby gets 5 preview branches, 1 custom dashboard, 3 alert destinations and Dev, Preview and Prod environments. Pro adds dedicated Slack support, 100+ alert destinations and AWS PrivateLink. Enterprise adds custom discounts, custom log retention, priority support, role-based access control, SSO, a SOC 2 report and a penetration test report.
What the Free plan lacks
- Credit stops the work. There is no overage on Free. When the $5 is gone, tasks stop until you upgrade or the month resets.
- 20 concurrent runs. The limits page lists 20 in production, 10 in staging, 10 in preview and 25 in development. Hobby raises production to 50, Pro to 200 or more.
- 1 day of logs. A failure from two days ago has no logs on Free. Hobby keeps 7 days, Pro 30.
- 10 schedules per project. A product that creates one cron schedule per customer hits this fast. Hobby allows 100, Pro 1,000 or more.
- Small Realtime limit. The pricing page lists 10 concurrent Realtime connections on Free. Hobby gets 150 and Pro 1,000+.
- Community support only. Dedicated Slack support starts on Pro.
- Preview branches. The Free column on the pricing page lists "Preview branches" with no count, and the limits page says "Not available" for Free. Hobby has 5.
- No HIPAA BAA. A BAA is a $500 a month add-on on Hobby and Pro, and is offered on request for Enterprise.
Worked examples with real math
The formula on the pricing page: runs x (seconds x price per second + $0.000025).
A small app: 2-second tasks on the default machine
One run is 2 x $0.0000338 + $0.000025 = $0.0000926.
- Free credit of $5 covers 5 / 0.0000926 = about 54,000 runs a month.
- That holds only at about 2 seconds a run. A 10 second run costs $0.000363 and the same $5 covers about 13,800 runs.
- At 100 runs a day of 10 seconds each, the pricing page's own example, the bill is $1.09 a month. Free covers it.
A 10-second task at 20,000 runs a month
One run is 10 x $0.0000338 + $0.000025 = $0.000363. Twenty thousand runs cost $7.26.
- Free: $5 of credit is not enough. The work stops once the credit is spent, around run 13,774.
- Hobby: $10 a month with $10 of credit included. The $7.26 of usage fits inside the credit, so the month costs $10.
A 30-person team at 1,000,000 runs a month
Assume 10-second tasks on Small 1x. Compute is 1,000,000 x 10 x $0.0000338 = $338. Invocation is 1,000,000 x $0.000025 = $25. Usage is $363.
- Pro fee: $50, which includes $50 of credit. Usage beyond the credit is $313.
- Seats: 25 included, so 5 extra x $20 = $100.
- Total: $50 + $313 + $100 = $463 a month.
- If the same tasks run 2 seconds each, usage is $92.60 and the total is $92.60 plus $100 for seats, $192.60 a month.
Trigger.dev against Inngest and Temporal
All three run durable background work, but they bill on different meters.
| Trigger.dev | Inngest | Temporal | |
|---|---|---|---|
| Entry tier | Free, $5 credit a month | Free, 50k executions a month | No base fee, $150 credit for new accounts, expires after 90 days |
| First paid tier | Hobby $10, Pro $50 | Pro from $99 a month | Business from $500 a month, or 10% of usage if higher |
| What is metered | Compute seconds by machine, plus $0.000025 per run | Executions: runs x (steps + 1) | Actions, from $50 per million |
| Open source | Apache 2.0, self-hostable | Core is open source, self-hostable | Server is MIT-licensed open source |
| Language focus | TypeScript | TypeScript, Python, Go | Go, Java, Python, TypeScript, .NET, PHP, Ruby, Rust |
Inngest figures come from its pricing page: Free is 50k executions and 5 concurrent steps, with no overage, and Pro includes 1M executions then $50 per million (an upper bound, since its FAQ describes tiered overage). Temporal's figures come from its pricing page.
Here is a like-for-like case: 1,000,000 runs a month. On Inngest, a one-step function is 2 executions per run, so 2M executions. That is $99 plus 1M extra at $50, or $149 at the upper-bound rate. On Trigger.dev, 2-second tasks on Small 1x come to $92.60 and 10-second tasks to $363. So the cheaper one depends on how long your tasks run. Inngest does not charge for task duration. Trigger.dev does.
Self-hosting: Apache 2.0, with exceptions
Trigger.dev's pricing FAQ says it is open source under Apache 2.0 and that you can self-host. The docs give Docker Compose and Kubernetes guides.
The documented minimums for Docker are:
- Webapp machine, hosting the dashboard, Postgres and Redis: 3+ vCPU and 6+ GB RAM
- Worker machine, hosting the supervisor and runs: 4+ vCPU and 8+ GB RAM
- Docker 20.10.0+ and Docker Compose 2.20.0+
Docs give sizing examples: 10 concurrent small-1x runs need 5 vCPU and 5 GB RAM, and 100 concurrent small-1x runs need 50 vCPU and 50 GB RAM. Self-hosted lacks warm starts, auto-scaling, checkpoints and dedicated support compared with Cloud. Without checkpoints, a waiting task is not paused for free the way it is on Cloud. The docs say the Docker guide alone is "unlikely to result in a production-ready deployment" and that you take responsibility for security, uptime and data integrity. Logs are never deleted when self-hosting.
Limits you will actually hit
- Run duration: no maximum. You set a default
maxDurationand can usetimeout.None. Trigger.dev says some users have runs lasting more than six months. - API rate limit: 1,500 requests per minute on all plans. Higher limits can be requested on paid plans.
- Batch size: up to 1,000 items per batch trigger on SDK 4.3.1 and later, 500 before that.
- Payload size: 3 MB per trigger payload, 10 MB for task output. Large payloads go to object storage.
- Queue size per queue: Free 10,000 in production, Hobby 250,000, Pro 1,000,000.
- Webhook ingest: 100 requests every 10 seconds per endpoint on Free, 300 on Hobby, 1,000 on Pro.
The pricing page also says you can set billing alerts at 75%, 90%, 100%, 200% and 500% of a monthly budget, with spike alerts up to 100x. Set them on a paid plan before you ship.
Who it is for
- A TypeScript or Next.js team that wants background work in the same repo, with the same review and deploy flow as the rest of the code.
- AI agent builders whose runs last minutes or hours. Trigger.dev positions itself for long-running agents, works with the Vercel AI SDK, and streams output to a frontend with Realtime.
- Teams with multi-day email or approval flows.
Who Trigger.dev is not for
- A team that writes mostly Python or Go and wants native SDKs. Inngest lists TypeScript, Python and Go.
- A product with heavy long-running compute at high volume, where per-second billing on big machines adds up. A Large 2x costs $2.448 an hour.
- A team that needs more than 20 concurrent runs or more than 1 day of logs and does not want to pay $10 a month.
Tips for your first weeks on Trigger.dev
- Install the CLI and run
devfirst. DEV runs are not charged, so build and test locally for free. - Pick the machine on purpose. Leave tasks on Small 1x until you see out-of-memory failures, then raise only those tasks. The docs show
TASK_PROCESS_OOM_KILLEDas the error. - Use
batchTrigger(), not a loop oftrigger(). Each SDK call is an API call, and the limit is 1,500 a minute. - Add a
deduplicationKeyto dynamic schedules. Without one, your task can be triggered several times, which costs more and hits the schedule limit. - Set a
maxDuration. A stuck task keeps billing by the second. - Set billing alerts before the first paid month.
How to get the Trigger.dev offer
- Go to trigger.dev and click Get started.
- Sign up. The Free plan needs no credit card and no promo code.
- Create a project, run the CLI init command, and write your first task in a
triggerfolder. - Test with the dev command, where runs are not charged.
- Deploy, and check the dashboard's Limits page for your real concurrency and quotas.
- Compare your expected seconds per run against the $5 credit. If you land near it, plan for Hobby at $10.
Who Is This Deal For?
Early-Stage Startups
Seed and pre-seed companies looking to move fast without overspending on tools.
Growing SaaS Teams
Series A+ companies scaling their stack and optimizing software costs.
Solo Founders
Indie hackers and bootstrapped founders who need enterprise tools at startup prices.
Get Free Plan off Trigger.dev
Premium deal. Upgrade once, unlock everything.
Frequently Asked Questions
Everything you need to know about this startup deal.
Get the weekly deals digest
New verified startup deals every week. No spam, ever. Unsubscribe anytime.
Related Offers
Retool
Used by 1,559 members
1 year free, up to $60K
Build internal tools 10x faster with the low-code platform used by companies like Amazon, DoorDash, and Mercedes-Benz.
View offerReplicate
Used by 1,772 members
$500 in credits
Run open-source ML models in the cloud, deploy Llama, Stable Diffusion, and custom models via API without GPU management.
View offerZoomInfo
Used by 2,014 members
Free Trial
B2B data platform for sales and marketing intelligence with contact databases.
View offerChore
15% off your first month
Chore runs your startup's back office for you: payroll, HR, bookkeeping, compliance and equity, inside the tools you already use. 15% off your first month through SaaSOffers.
View offerDeal Summary
Looking for more startup deals?
Browse all offers