# Limits and Pricing for Render Workflows

Render bills for the following components of workflows:

| Billable | Description |
| --- | --- |
| *Compute usage* | Render bills for each task run based on its compute plan and duration. [See details](#compute-plans). |
| *Retention of task state* | Render temporarily retains the input arguments and return value of each task run to support retries and debugging. [See details](#task-state-retention). |

If your task runs send network requests over the public internet, that traffic contributes to your workspace's usage of outbound bandwidth.

## Compute plans

Each task run executes on one of the following compute plans, which determines its specs and pricing:

The `starter` and `standard` compute plans from the Render Workflows beta have been discontinued in favor of [`flex`](/workflows-limits#the-flex-compute-plan).

- The `flex` plan is now the default for any task that doesn't [specify a different plan](/workflows-defining#compute-plan).
- Any task that sets its plan to `starter` or `standard` now automatically uses `flex` instead.
- The `flex` plan is billed according to your task run's actual RAM and CPU usage. This results in lower costs for most tasks that previously used `starter` or `standard`.
- The `flex` plan provides up to the same CPU as `standard` and double the RAM.

| Compute Plan | Specs | Price |
| --- | --- | --- |
| *`flex`* (default) | _Up to_ 1 CPU _Up to_ 4 GB RAM | Varies with CPU/RAM usage ([see details](#the-flex-compute-plan)) |
| *`2c-4g`* (Formerly `pro`) | 2 CPU 4 GB RAM | $0.40 / hour ($0.00666667 / minute, $0.00011111 / second) |
| *`2c-8g`* | 2 CPU 8 GB RAM | $0.70 / hour ($0.01166667 / minute, $0.00019444 / second) |
| *`4c-8g`* (Formerly `pro_plus`) | 4 CPU 8 GB RAM | $1.00 / hour ($0.01666667 / minute, $0.00027778 / second) |
| *`4c-16g`* (Formerly `pro_max`) | 4 CPU 16 GB RAM | $1.50 / hour ($0.02500000 / minute, $0.00041667 / second) |

- Billing for compute usage is prorated by the second.
    - If a task run executes on the `2c-4g` compute plan for a half-hour, Render bills you $0.20, not $0.40.
- You can specify which compute plan to use for each task in your workflow. [Learn how](/workflows-defining#compute-plan).

> *Need larger workflow compute plans?*
>
> Reach out with details about your use case:

### The `flex` compute plan

The `flex` compute plan is special: it's billed based on the CPU and RAM a task run actually uses, _not_ the plan's maximum specs (1 CPU, 4 GB RAM). All other compute plans are billed at a fixed rate based on specs.

*Pricing for `flex` is as follows:*

| Resource | Price | Notes |
| --- | --- | --- |
| CPU | $0.20 / CPU-hour ($0.00333333 / CPU-minute, $0.00005556 / CPU-second) | Measured as cumulative virtual CPU time over the task run's full duration |
| RAM | $0.05 / GB-hour ($0.00083333 / GB-minute, $0.00001389 / GB-second) | Sampled multiple times per second |

If a `flex` run _constantly_ uses the entirety of its available CPU and RAM, it's billed at the maximum rate of $0.40 / hour. But for tasks that use fewer resources, the rate can be dramatically lower:

| Avg CPU | Avg RAM | Flex price |
| --- | --- | --- |
| 0.1 | 0.2 GB | $0.02 + $0.01 = *$0.03 / hour* ($0.00033333 + $0.00016667 ≈ *$0.00050000 / minute*, $0.00000556 + $0.00000278 ≈ *$0.00000833 / second*) |
| 1 | 1 GB | $0.20 + $0.05 = *$0.25 / hour* ($0.00333333 + $0.00083333 ≈ *$0.00416667 / minute*, $0.00005556 + $0.00001389 ≈ *$0.00006944 / second*) |
| 1 | 4 GB | $0.20 + $0.20 = *$0.40 / hour* ($0.00333333 + $0.00333333 ≈ *$0.00666667 / minute*, $0.00005556 + $0.00005556 ≈ *$0.00011111 / second*) (Full usage) |

Render applies a minimum charge to extremely small `flex` runs, equivalent to one second of execution at 0.1 CPU and 0.1 GB RAM.

## Task state retention

Render temporarily retains the [input arguments](/workflows-defining#task-arguments) and return value of each task run to support retries, debugging, and observability. This *task state* is retained for 30 days.

Retention of task state is billed monthly at *$0.25 per GB*. Render bills for each task run's state only once (even though task state is often retained across multiple billing periods).

For example, if the combined size of all your task run inputs and return values in a billing period is 200 MB, Render bills you $0.05.

## Compute limits

A workflow service has a maximum amount of CPU and RAM it can provision _in total_ and _per minute_ for its task runs:

------

##### Total compute

A workflow service's active task runs can have combined compute specs totaling up to *10,000 CPU* and *40,000 GB RAM*.

##### New compute per minute

Every minute, a workflow service can create _new_ task runs with combined specs totaling up to the following CPU and RAM limits (based on your workspace plan):

| Workspace Plan | CPU per minute | RAM per minute |
|----------------|----------------|----------------|
| *Hobby*          | 16 CPU     | 64 GB          |
| *Pro or higher*  | 32 CPU     | 128 GB         |

> *The [`flex` compute plan](#the-flex-compute-plan) only counts _actual_ CPU and RAM usage against these limits.*
>
> This means that if you spin up "lightweight" `flex` runs, you can create many more per minute than implied by the plan's max specs (1 CPU, 4 GB RAM).
>
> [Compute plans](#compute-plans) besides `flex` always count their full specs against these limits.

------

If a new task run would exceed a compute limit, Render queues it as usual. Queued runs spin up in order as resources become available.

> *Need to increase these workflow limits?*
>
> Reach out with details about your use case:

## API rate limits

Render enforces separate API rate limits for triggering *root-level task runs* and *chained runs*. These limits are enforced at the workspace level, _not_ per-workflow.

------

##### Root-level runs

These are the task runs you trigger from any source outside the workflow itself (web apps, agents, CI/CD, and so on).

All mechanisms for [triggering a root-level task run](/workflows-running) (including the Render SDK) use the Render API's [Run task](https://api-docs.render.com/reference/createtask) endpoint under the hood.

The Run task endpoint enforces the following rate limits _per workspace_:

| Workspace Plan     | Per-workspace rate limit |
|--------------------|--------------------------|
| *Hobby*          | 50 requests per minute   |
| *Pro or higher*  | 1500 requests per minute |

Whenever a request to this endpoint is rate limited, Render returns a 429 error. In this case, Render does _not_ queue the run.

##### Chained runs

These are the task runs you trigger from within _another_ run that belongs to the same workflow service. [Learn more.](/workflows-defining#chaining-task-runs)

Render enforces a workspace-level rate limit of *1000 chained runs per minute*.

Whenever an attempted chained run is rate limited, the call to `ctx.run()` fails with an error. In this case, Render does _not_ queue the run.

------

## Additional limits

| Limit | Description |
| --- | --- |
| *Run duration* | By default, task runs time out after *2 hours*. You can extend this to up to *24 hours* on a [per-task basis](/workflows-defining#timeout). |
| *Argument size* | The total size of all [arguments](/workflows-defining#task-arguments) passed to a single task run cannot exceed *4 MB*. |
| *Task definitions* | A single workflow service can register a maximum of *500* different tasks. |


---

##### Appendix: Glossary definitions

###### Render Workflows

Define collections of long-running *tasks* that execute across distributed compute.

Ideal for agents, ETL pipelines, and background jobs.

Related article: https://render.com/docs/workflows.md

###### task run

A single execution of a workflow *task*.

A run spins up in its own *instance*, executes, returns a value, and is deprovisioned.

Related article: https://render.com/docs/workflows-running.md

###### compute plan

Specifies the CPU and RAM available to your service's *instances*.

Common compute plans for a new web service include:

- *`free`*: 0.1 CPU / 512 MB RAM
- *`0.5c-512mb`*: 0.5 CPU / 512 MB RAM
- *`1c-2g`*: 1 CPU / 2 GB RAM

Compute plans were previously known as *instance types*.

Related article: https://render.com/docs/compute-plans.md

###### outbound bandwidth

The amount of network traffic you send to destinations outside of Render (HTTP responses, third-party API calls, and so on).

Your workspace receives a monthly included amount of outbound bandwidth. If you exceed this amount, Render bills you for a supplementary amount.

Related article: https://render.com/docs/outbound-bandwidth.md

###### run chaining

Triggering a new *task run* directly from an in-progress run.

All runs in a chain belong to the same *workflow*.

Related article: https://render.com/docs/workflows-defining.md#chaining-task-runs

###### task

A function you can execute on its own compute as part of a *workflow*.

Each execution of a task is called a *run*.

Related article: https://render.com/docs/workflows-defining.md