GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing trigger.dev — Limits - Trigger.dev

You can view your current limits, quotas, and rate limit usage in real-time by visiting the Limits page in the dashboard (accessible from the left sidebar). This page shows current rate limit token availability, quota usage, and plan features for your organization.

Looking to cap your monthly spend? That’s a setting you control, not a platform limit — see Billing limits and alerts.

Run duration

Runs have no maximum duration. You set a default maxDuration for your project and can override it per task or per run, or set it to timeout.None to let a run execute indefinitely. Trigger is built for long running AI agents and workflows and we have seen Trigger.dev users with runs lasting more than six months.

Concurrency limits

Concurrency is allocated per environment, not as a single figure for the whole organization. Each plan sets a separate default for production, staging, preview and development:

Pricing tier	Production	Staging	Preview	Development
Free	20	10	10	25
Hobby	50	25	25	25
Pro	200+	100	100	25

These are plan defaults. The limit actually enforced for one of your environments can be higher: purchased add-on concurrency and any manual increase we have applied are both included in it. The Concurrency page in the dashboard (left sidebar) is authoritative for your organization — if it disagrees with the table above, the dashboard is correct. Extra concurrency above the Pro tier limit is available via the dashboard. Click the “Concurrency” page from the left sidebar when on the Pro plan to purchase more.

Rate limits

Generally speaking each SDK call is an API call.

Limit	Details
API	1,500 requests per minute

You can request a higher rate limit from us if you’re on a paid plan. The most common cause of hitting the API rate limit is if you’re calling trigger() on a task in a loop, instead of doing this use batchTrigger() which will trigger multiple tasks in a single API call. You can have up to 1,000 tasks in a single batch trigger call with SDK 4.3.1+ (500 in prior versions).

Queued tasks

The maximum number of runs that can be queued per queue (not across all queues in the environment). Each queue can hold up to its limit independently. When a queue hits its limit, new triggers to that queue are rejected.

The limits below apply to Trigger.dev Cloud. If you self-host Trigger.dev, queue size limits are configurable via the MAXIMUM_DEV_QUEUE_SIZE and MAXIMUM_DEPLOYED_QUEUE_SIZE environment variables — see Self-hosting environment variables.

Pricing tier	Development (per queue)	Staging / Production (per queue)
Free	500	10,000
Hobby	500	250,000
Pro	5,000	1,000,000

Maximum run TTL

On Trigger.dev Cloud, all runs have an enforced maximum TTL of 14 days. Runs without an explicit TTL automatically receive the 14-day TTL; runs with a TTL longer than 14 days are clamped to 14 days. This prevents queued runs from accumulating indefinitely. The TTL cap does not limit how far ahead you can schedule a run. TTL governs how long a run may sit queued waiting for a concurrency slot. A run triggered with delay is not queued while it is delayed, and no TTL expiry is armed for it — the TTL clock only starts once the delay elapses and the run is enqueued. So scheduling a run a month out with delay works fine, and the 14 days then applies to how long it may wait for a slot after that month is up. There is no maximum on delay. If you self-host, you can configure a maximum TTL via the RUN_ENGINE_DEFAULT_MAX_TTL environment variable — see Self-hosting environment variables.

Schedules

Pricing tier	Limit
Free	10 per project
Hobby	100 per project
Pro	1,000+ per project

Additional bundles above the Pro tier are available for $10/month per 1,000 schedules. Contact us via email or Discord to request more. When attaching schedules to tasks we strongly recommend you add them in our dashboard if they’re “static”. That way you can control them easily per environment. If you add them dynamically using code make sure you add a deduplicationKey so you don’t add the same schedule to a task multiple times. If you don’t your task will get triggered multiple times, it will cost you more, and you will hit the limit. If you’re creating schedules for your user you will definitely need to request more schedules from us.

Projects

Pricing tier	Limit
All tiers	10 per organization

Each project receives its own concurrency allocation. If you need to support multiple tenants with the same codebase but different environment variables, see the Multi-tenant applications section for a recommended workaround.

Preview branches

Pricing tier	Limit
Free	Not available
Hobby	5 preview branches
Pro	20+ preview branches

Additional bundles above the Pro tier are available for $10/month per preview branch. Contact us via email or Discord to request more.

Realtime connections

Pricing tier	Limit
Free	10 concurrent connections
Hobby	50 concurrent connections
Pro	500+ concurrent connections

Additional bundles are available for $10/month per 100 concurrent connections. Contact us via email or Discord to request more.

Task payloads and outputs

Limit	Details
Single trigger payload	Must not exceed 3MB
Batch trigger payload	Each item can be up to 3MB (SDK 4.3.1+). Prior: 1MB total combined
Task outputs	Must not exceed 10MB

Large payloads and outputs are offloaded to object storage automatically. You don’t need to do anything to handle this in your tasks, as we upload and download the data transparently during operation. On the way in, the SDK uploads any trigger or batch-item payload over 128KB to object storage before sending, so large triggers and batches don’t exceed the request body limit. trigger and triggerAndWait have done this since SDK 4.5.0, and batchTrigger and batchTriggerAndWait (including the by-id and by-task variants) do too from SDK 4.5.2. Payloads and outputs over 512KB are kept in object storage rather than inline. Calling runs.retrieve returns that offloaded data as a presigned download URL (payloadPresignedUrl / outputPresignedUrl).

Batch size

A single batch can have a maximum of 1,000 items with SDK 4.3.1+. Prior versions are limited to 500 items.

Batch trigger rate limits

Batch triggering uses a token bucket algorithm to rate limit the number of runs you can trigger per environment. Each run in a batch consumes one token.

Pricing tier	Bucket size	Refill rate
Free	1,200 runs	100 runs every 10 sec
Hobby	5,000 runs	500 runs every 5 sec
Pro	5,000 runs	500 runs every 5 sec

How it works: You can burst up to your bucket size, then tokens refill at the specified rate. For example, a Free user can trigger 1,200 runs immediately, then must wait for tokens to refill (100 runs become available every 10 seconds).

When you hit batch rate limits, the SDK throws a BatchTriggerError with isRateLimited: true. See Handling batch trigger errors for how to detect and react to rate limits in your code.

Batch trigger processing concurrency

When you send a batch trigger, we convert it into individual runs. This limit controls the maximum number of batches being converted into runs simultaneously per environment. It is not a limit on how many batch runs can be executing at once.

Pricing tier	Limit
Free	5 concurrent batches
Hobby	10 concurrent batches
Pro	50 concurrent batches

Webhook ingest rate limits

Each hosted webhook endpoint accepts a limited number of requests per 10 seconds. Requests over the limit get a 429 response with a Retry-After header, and providers that retry deliver them again after the window.

Pricing tier	Requests per endpoint
Free	100 every 10 sec
Hobby	300 every 10 sec
Pro	1,000 every 10 sec
Enterprise	Set per organization

All of an environment’s endpoints also share a per-environment limit, counted in tokens: a request costs one token for every 64 KiB of body, started, so a 10 KiB event costs one and a 1 MiB event costs 16. Requests over it get the same 429 with Retry-After.

Pricing tier	Tokens per environment
Free	300 every 10 sec
Hobby	1,000 every 10 sec
Pro	3,000 every 10 sec
Enterprise	Set per organization

Webhook waiters

A waiter is a run paused until a matching webhook arrives. The per-endpoint limit is also the most waiting runs one delivery can resume.

Pricing tier	Live waiters per environment	Live waiters per endpoint
Free	500	100
Hobby	2,000	1,000
Pro	25,000	10,000
Enterprise	Set per organization	Set per organization

A waiter can wait for up to 90 days.

Webhook processing concurrency

This limit controls how many webhook deliveries and waiter resumes are processed at once per environment. Additional deliveries wait their turn. It is not a limit on the runs those deliveries start, which use your normal concurrency limits.

Pricing tier	Limit
Free	5 concurrent deliveries
Hobby	10 concurrent deliveries
Pro	50 concurrent deliveries
Enterprise	Set per organization

Webhook delivery retention

How long deliveries stay visible in the dashboard and the API.

Pricing tier	Limit
Free	3 days
Hobby	7 days
Pro	30 days
Enterprise	90, 180 or 365 days

By default, deliveries are stored for at least 30 days, so upgrading your plan shows older deliveries that are still stored. An organization can ask us to store deliveries only for its retention period instead. Deliveries past that period are then deleted and can’t be shown again after an upgrade.

Webhook subscribers

An endpoint can have up to 25 subscribers (tasks, agent sessions and channels) on every plan.

Log retention

Pricing tier	Limit
Free	1 day
Hobby	7 days
Pro	30 days

Log size

We limit the size of logs to prevent oversized data potentially causing issues.

Show log limits

Attribute Limits

Span Attribute Count Limit: 1024
Log Attribute Count Limit: 1024
Span Attribute Value Length Limit: 131072 characters
Log Attribute Value Length Limit: 131072 characters

Event and Link Limits

Span Event Count Limit: 10
Link Count Limit: 2
Attributes per Link Limit: 10
Attributes per Event Limit: 10

I/O Packet Length Limit

128 KB (131,072 bytes)

Attribute Clipping Behavior

Attributes exceeding the value length limit (131072 characters) are discarded.
If the total number of attributes exceeds 1024, additional attributes are not included.

Attribute Value Size Calculation

Strings: Actual length of the string
Numbers: 8 bytes
Booleans: 4 bytes
Arrays: Sum of the sizes of all elements
Undefined or null: 0 bytes

Alerts

An alert destination is a single email address, Slack channel, or webhook URL that you want to send alerts to.

Pricing tier	Limit
Free	1 alert destination
Hobby	3 alert destinations
Pro	100+ alert destinations

If you’re on the Pro plan and need more than the plan limit, you can request more by contacting us via email or Discord.

Query

Query execution is subject to the following limits:

Limit	Details
Max execution time	10 seconds per query
Max result rows	10,000 rows per query
Concurrent queries	3 per project

Query lookback period

The maximum time range a query can look back is based on your plan:

Pricing tier	Limit
Free	1 day
Hobby	7 days
Pro	30 days

If your query’s time range exceeds your plan’s lookback limit, it will be automatically clipped to the maximum allowed period.

Metric widget concurrency

The number of metric widgets that can be queried concurrently per project.

Limit	Details
Concurrent widget queries	30 per project

Machines

The default machine is small-1x which has 0.5 vCPU and 0.5 GB of RAM. You can optionally configure a higher spec machine which will increase the cost of running the task but can also improve the performance of the task if it is CPU or memory bound. See the machine configurations for more details.

Team members

Pricing tier	Limit
Free	5 team members
Hobby	5 team members
Pro	25+ team members

Additional seats are available for $20/month per seat. Contact us via email or Discord to request more.

Was this page helpful?

⌘I

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.

GeezerVison

​Run duration

​Concurrency limits

​Rate limits

​Queued tasks

​Maximum run TTL

​Schedules

​Projects

​Preview branches

​Realtime connections

​Task payloads and outputs

​Batch size

​Batch trigger rate limits

​Batch trigger processing concurrency

​Webhook ingest rate limits

​Webhook waiters

​Webhook processing concurrency

​Webhook delivery retention

​Webhook subscribers

​Log retention

​Log size

​Attribute Limits

​Event and Link Limits

​I/O Packet Length Limit

​Attribute Clipping Behavior

​Attribute Value Size Calculation

​Alerts

​Query

​Query lookback period

​Metric widget concurrency

​Machines

​Team members