The Trigger.dev free tier gives you $5 in monthly compute credits, 20 concurrent production runs, and unlimited tasks with no credit card. One-day log retention, no preview branches, and a hard stop once the $5 runs out make it a development and small-production tier, not a free production backend.
For indie hackers and bootstrappers, the key question is less “Is it free?” and more “Will its limits fit my workflow?” This guide covers the plan, compute charges, operational limits, and cost controls, using figures from Trigger.dev’s published pricing and documentation.
This review is based on official documentation and pricing pages — we did not run the tool hands-on. Trigger.dev Pricing and Trigger.dev Limits are the primary sources for the plan and platform limits discussed below.
What the Trigger.dev Free Plan Includes
The Free plan costs $0 per month, requires no credit card, and includes $5 in monthly credits, unlimited tasks, and 20 concurrent production runs. It also includes Dev and Prod environments, 5 team members, 10 schedules, one alert destination, and limited retention and query history. Trigger.dev Pricing Trigger.dev Limits
The main trade-off is not a task-count ceiling. It is the budget and the short history available for debugging. The table compares paid plans as context only.
| Plan limit | Free | Hobby | Pro |
|---|---|---|---|
| Price | $0/month | $10/month | $50/month |
| Included credits | $5/month | $10/month | $50/month |
| Concurrent production runs | 20 | 50 | 200+ |
| Team members | 5 | 5 | 25+ |
| Schedules per project | 10 | 100 | 1,000+ |
| Log retention | 1 day | 7 days | 30 days |
| Alert destinations | 1 | 3 | 100+ |
| Concurrent Realtime connections | 10 | 150 (pricing page) / 50 (limits docs) | 500+ |
| Queued tasks per queue, Staging/Production | 10,000 | 250,000 | 1,000,000 |
| Preview branches | Not available (limits docs; the pricing page lists them on Free) | 5 | 20+ |
| Query lookback | 1 day | 7 days | 30 days |
Trigger.dev Pricing Trigger.dev Limits
The Hobby Realtime figure differs between the two sources, so confirm current details before relying on it.
How the $5 Monthly Credit Is Spent
Credits pay for machine compute per second and a $0.000025 invocation charge for each run, which is $0.25 per 10,000 runs. Dev-environment runs are not charged. The published example puts a 10-second small-1x task at $0.000363 per run and about $1.09 per month at 100 runs per day. Trigger.dev Pricing
The per-second compute rates are:
| Machine | Resources | Compute rate |
|---|---|---|
| Micro | 0.25 vCPU / 0.25 GB | $0.0000169/sec |
| Small 1x (default) | 0.5 vCPU / 0.5 GB | $0.0000338/sec |
| Small 2x | 1 vCPU / 1 GB | $0.0000675/sec |
| Medium 1x | 1 vCPU / 2 GB | $0.0000850/sec |
| Medium 2x | 2 vCPU / 4 GB | $0.0001700/sec |
| Large 1x | 4 vCPU / 8 GB | $0.0003400/sec |
| Large 2x | 8 vCPU / 16 GB | $0.0006800/sec |
Trigger.dev Pricing Machine sizes
For the documented small-1x example, the calculation is (10 × $0.0000338) + $0.000025 = $0.000363/run. At 100 runs per day, that is $0.0363/day, or about $1.09/month on the pricing FAQ’s 30-day basis. This is arithmetic from published rates, not a measured workload. At that volume and task length, $5 covers about 4.6 times the monthly volume in the example.
Waiting can reduce compute charges. wait.for and wait.until waits longer than 5 seconds checkpoint and are not billed as compute, and a parent waiting on triggerAndWait subtasks is not billed for that wait. Trigger.dev Pricing Waits
Concurrency, Rate Limits, and Queue Caps That Actually Bite on Free
Free production concurrency is 20 runs. Free batch triggering uses a bucket of 1,200 runs that refills by 100 every 10 seconds. These are separate constraints: active runs, API calls, and bursts of batch work each have their own ceiling. Trigger.dev Limits
The limits page publishes a concurrency default for each environment on Free: 20 in Production, 10 in Staging, 10 in Preview, and 25 in Development. The Preview default is a platform setting, even though the same page lists preview branches as unavailable on Free. A batchTrigger call can include up to 1,000 tasks with SDK 4.3.1 or later; earlier SDK versions support 500 per call. Free batch processing concurrency is 5. Trigger.dev Limits
Other limits to account for:
- The API rate limit is 1,500 requests per minute on all plans. Trigger.dev Limits
- Hobby and Pro have a 5,000-run batch bucket, refilling by 500 every 5 seconds; batch processing concurrency is 10 on Hobby and 50 on Pro. Trigger.dev Limits
- Webhook ingest is limited to 100 requests per 10 seconds per endpoint on Free. Trigger.dev Limits
- Free allows 10,000 queued tasks per Staging or Production queue and 500 in Development. Cloud runs waiting for a slot have a maximum run TTL of 14 days. Trigger.dev Limits
- A single trigger payload can be up to 3 MB and task output up to 10 MB; payloads over 512 KB are offloaded to object storage. Trigger.dev Limits
- An organization can have 10 projects across all tiers. Trigger.dev Limits
Free-Tier Traps: What Actually Stops You
Four limits matter most on Free: preview branches are unavailable, logs and query lookback last one day, queued runs expire after a 14-day TTL on Cloud, and tasks stop when the included $5 credit is used. Trigger.dev Pricing Trigger.dev Limits
No preview branches (with a source conflict). The limits documentation says preview branches are not available on Free, and lists them on paid tiers only. The pricing page lists preview branches among Free features. This guide follows the limits page; confirm in the dashboard before you plan a preview workflow. Trigger.dev Limits Trigger.dev Pricing
Short debugging window. Free logs are retained for 1 day, and query lookback is 1 day. A failure older than that cannot be investigated from Free retained logs or queries, so teams that need longer post-incident history should plan for it. Trigger.dev Pricing Trigger.dev Limits
Queued runs expire. Cloud runs waiting for a slot have a maximum TTL of 14 days. A run with delay is not queued during the delay, and delay has no maximum, so scheduling far ahead is not capped by the TTL. Trigger.dev Limits Delayed triggers
Credit exhaustion stops tasks. Trigger.dev’s pricing FAQ says, “On the Free plan, you’ll need to upgrade to keep running tasks once the included $5 of credits is used.” That is a direct continuity risk if a workload reaches the budget before you decide to upgrade. Trigger.dev Pricing
Billing Limits and Alerts: A Soft Cap, Not a Brake
Billing limits are soft. They apply to Production, Staging, and Preview but not Dev, and reaching one starts a 24-hour grace period rather than an instant spending stop. Usage is evaluated with a short delay, so costs can briefly exceed the configured limit. Alerts only notify and never pause or reject runs. Trigger.dev Billing Limits Trigger.dev Pricing
An organization can set its billing limit to the plan limit, a custom amount, or no limit, which is the default. There is also an optional setting to cancel in-progress runs when a limit is reached. Trigger.dev Billing Limits
When the limit is reached, queues pause and in-progress runs finish unless cancellation is enabled. New runs queue but do not start during the grace period. The organization then has 24 hours to decide; afterward, new triggers are rejected until the limit is raised or removed. Limits reset each billing cycle. Trigger.dev Billing Limits
On Free, the $5 credit is the effective ceiling whether or not a billing limit is configured: the pricing FAQ says tasks stop until you upgrade once it is used. The billing-limit grace period is a separate mechanism that governs organization spend when a limit is set. Standard email alerts fire at 75%, 90%, 100%, 200%, and 500% of the monthly budget, and spike alerts can catch runaway usage up to 100x. Trigger.dev Pricing Trigger.dev Billing Limits
Cutting Spend: Waits, Idempotency, Debounce, Machine Size
The biggest cost levers are checkpointed waits instead of polling, idempotency keys that prevent duplicate work, the default small-1x machine, and a per-task maxDuration. The Usage page shows which tasks are expensive, and retry settings control repeat work. Trigger.dev Reduce Spend
- Find costly tasks first. Open Organization menu > Usage to see the most expensive tasks, then focus optimization there. Trigger.dev Reduce Spend
- Keep machine sizes appropriate. Small-1x is the default. Choose a larger machine only when a task needs it. Machine sizes Trigger.dev Reduce Spend
- Prevent duplicate work. Set
idempotencyKeyandidempotencyKeyTTL; the default TTL can be up to 30 days. Trigger.dev Reduce Spend - Wait instead of polling. Prefer
wait.for,wait.until, ortriggerAndWaitover polling loops. Waits - Debounce rapid triggers. Use
debounceto consolidate bursts of triggers into one run. Triggering - Cap runaway runs. Set
maxDurationper task so a stuck run stops instead of running on. Trigger.dev Reduce Spend - Limit retries. Set a lower
maxAttemptsfor non-critical tasks, and useAbortTaskRunErrorfor permanent errors that should not retry. Retry options Errors and retrying
When to Self-Host
Trigger.dev is open source under the Apache 2.0 license. The self-hosted version lacks warm starts, auto-scaling, checkpoints, and dedicated support, and billing limits do not apply to it. Its deployment is a set of containers: a webapp with the dashboard, Redis, and Postgres, and a worker with the supervisor and runners. Trigger.dev Pricing Self-hosting overview Open-source self-hosting
Most limits can be configured through environment variables on the webapp. The I/O packet length is hardcoded at 128 KB, and self-hosted logs are never deleted. The docs do not publish resource requirements, so size the server from your own load before committing. Environment variables Self-hosting overview
If you still run v3 tasks, note that Trigger.dev 4.5.0 is the last version that supports them, so plan a move to v4. Migrating from v3
Quick-Start: init, dev, and a Test Run (Next.js)
For Next.js, npx trigger.dev@latest init scaffolds the /trigger folder, trigger.config.ts, and an example task. npx trigger.dev@latest dev starts a local server that registers tasks. Trigger.dev Next.js Guide
From an App Router route handler, the guide triggers a task with tasks.trigger<typeof helloWorldTask>("hello-world", "James"). Put a Dev-environment API key with Trigger-only access in .env.local as TRIGGER_SECRET_KEY. Dev runs are not charged, so local iteration does not consume production credits. Trigger.dev Next.js Guide API keys
tasks.trigger<typeof helloWorldTask>("hello-world", "James")FAQ
What happens when the $5 free credit runs out?
When the included Free credit is used, tasks stop until you upgrade. The pricing FAQ states that an upgrade is required to keep running tasks, so decide your response before a workload reaches that point. Trigger.dev Pricing
Can I use preview branches on the free plan?
The limits documentation says no: preview branches are not available on Free and are listed for paid tiers only. The pricing page lists them among Free features, so confirm in the dashboard before you depend on them. Trigger.dev Limits Trigger.dev Pricing
Is the billing limit a hard stop on spending?
No. Billing limits are soft, and usage is evaluated on a short delay, so spend can briefly exceed the configured amount. Reaching the limit starts a 24-hour grace period, after which new triggers are rejected until the limit is raised or removed. Trigger.dev Billing Limits
The Bottom Line
Trigger.dev Free is usable for development and small production workloads. One-day logs, no preview branches, and a credit stop make it a poor fit for workloads that need longer debugging history or uninterrupted tasks. Set a billing limit and alerts on day one, and compare the $10/month Hobby plan against your real usage once Free constraints become operational blockers. Trigger.dev Pricing Trigger.dev Limits Trigger.dev Billing Limits
How This Guide Was Built (E-E-A-T)
This guide uses Trigger.dev pricing and documentation fetched on 2026-10-16. We did not run the tool hands-on. Each figure links to its source, and points the sources do not cover are listed as gaps rather than stated as facts. Trigger.dev Pricing Trigger.dev Limits
Not verified: Hobby and Pro credit-to-run equivalence beyond the pricing page, real-world run counts per $5 credit, and self-hosting resource requirements. Trigger.dev Pricing Self-hosting overview