> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orgo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Account limits and rate limits

> How many computers, workspaces and people your plan allows, how big one computer can be, every rate limit, and what the API answers when you reach one.

Pools, people per workspace and API rate limits differ by plan. The computer limit is the same on every plan. What each plan costs is in [Plans and billing](https://docs.orgo.ai/guides/billing.md) and [Computer prices](https://docs.orgo.ai/guides/pricing.md).

## Whose limits apply

Limits belong to the workspace owner's account, not to the person or key making the request.

* **One account, every workspace.** Computers in all the workspaces you own count together. A computer a member creates in your workspace counts against your plan, not theirs.
* **The account pool.** Each paid plan includes vCPU and RAM that all of the account's plan computers share. A computer holds its vCPU and RAM from the pool until you delete it, whether it is running, stopped or asleep.
* **See where you stand.** The [Usage](https://www.orgo.ai/settings/usage) page shows what you use against each limit. From code, [Get capacity](https://docs.orgo.ai/api-reference/account/capacity.md) returns your computer, RAM and vCPU limits and what you use of each.
* **Two exceptions.** Publishing, building and test-running templates follow your own plan, whoever owns the workspace. The endpoint limits in [Endpoint limits](#endpoint-limits) count what each table names, and an account there is your own, not the workspace owner's. The [Plan rate limits](#plan-rate-limits) follow the rule above: the workspace owner's account.

## Limits by plan

| | Free | Starter | Growth | Scale | Enterprise |
| - | - | - | - | - | - |
| vCPU pool | None | 2 | 8 | 36 | Custom |
| RAM pool | None | 8 GB | 32 GB | 128 GB | Custom |
| Computers, plan and hourly together | 50, or 1 on signup credit alone | 50 | 50 | 50 | 999, or your contract's number |
| Disk per computer, before add-ons | 40 GB, on a Medium by the hour | 40 GB | 80 GB | 150 GB | Custom |
| Workspaces | 9999 | 9999 | 9999 | 9999 | 9999 |
| People per workspace, besides the owner | 0 | 1 | 5 | 25 | Custom |

* **Computers** past 50 run by the hour from your credit, up to 999 in all, as described in [Computers per account](#computers-per-account).
* **Free** has no plan, so every computer it has runs by the hour. Its \$5 of signup credit runs one Medium computer (2 vCPU, 8 GB RAM, 40 GB disk). Credit you buy lifts it to the 50 every plan has, all Medium, as described in [Computers by the hour](#computers-by-the-hour).
* **Enterprise** pools, disk and people are set per account in your contract, and so is its computer count when the contract names one. [Contact us](mailto:contact@orgo.ai) for any of them.
* **Starter's pool holds one Medium.** A Large (4 vCPU, 16 GB) on an empty Starter account is refused with `This size needs 16 GB of memory. Your plan allows 8 GB per computer.` (code `RAM_ADDON`). `cpu: 4` with `ram: 4` is refused with `You have 2 vCPU free. This size needs 4.` (code `VCPU_ADDON`).
* **Some older accounts carry an extra vCPU allowance** from before vCPU limits began. The limit on Usage and in Get capacity includes it.
* **Templates.** Any paid plan can launch them. Publishing, building and test-running templates needs Scale or Enterprise on your own plan, whoever owns the workspace, as described in [Templates](https://docs.orgo.ai/guides/templates/introduction.md).

### Plans no longer sold

Older plans keep the numbers they were sold with, and every one has the computer limit in [Computers per account](#computers-per-account). If your plan's own pool, before add-ons, differs from the table above, your plan is one of these. Some of them share a name with a current plan. The `plan` field in [Get capacity](https://docs.orgo.ai/api-reference/account/capacity.md) tells them apart: the current plans are `hacker_v2` (Starter), `startup_v2` (Growth) and `scale_v2` (Scale), and the first column below gives each older plan's value.

| Plan | vCPU pool | RAM pool | Disk per computer, before add-ons | People per workspace | Windows |
| - | - | - | - | - | - |
| Starter, 20 GB (`hacker`) | 5 | 20 GB | 20 GB | 1 | A licence per computer |
| Developer (`developer`) | 10 | 20 GB | 20 GB | 1 | A licence per computer |
| Team (`team`) | 20 | 80 GB | 30 GB | 5 | A licence per computer |
| Growth, 200 GB (`startup`) | 100 | 200 GB | 9 GB | 5 | Included |
| Scale, 200 GB (`scale`) | 100 | 200 GB | 50 GB | 25 | Included |
| Max (`max`) | 100 | 200 GB | 27 GB | 25 | Included |

A new computer on one of these plans starts with 20 GB of disk, or the plan's disk per computer when that is less. Growth (200 GB), Scale (200 GB) and Max can also publish templates.

### How far add-ons go

Add-ons raise your pools and the disk one computer can have, at the prices in [Computer prices](https://docs.orgo.ai/guides/pricing.md). They need a paid plan. On your own, an account can add up to:

| Add-on | Most per account |
| - | - |
| RAM | 800 GB |
| vCPU | 200 vCPU |
| Storage | 4,000 GB, in 20 GB blocks |

One purchase through [Add capacity](https://docs.orgo.ai/api-reference/account/add-capacity.md) buys 1 to 500 computers' worth. Past the amounts above, it answers `403` with code `capacity_cap`: `That would go past this account's limit of ... Ask us to raise it.` Add-ons never take one computer past the per-computer caps in [How big one computer can be](#how-big-one-computer-can-be).

## Computers per account

An account has one computer limit: every computer it has, plan and hourly together, in every workspace it owns, running or stopped. Nothing limits how many of them run at once.

| Account | Computers before credit raises it | Most computers |
| - | - | - |
| Free, Starter, Growth and Scale | 50 | 999 |
| Free, on its signup credit alone | 1 | 1 |
| Enterprise | 999 | 999 |
| An account Orgo gave its own number | That number | 999, or that number when it is higher (up to 9999) |

The first number is the account's **baseline**. Orgo gives its own number to a negotiated plan, an Enterprise contract that names one, and an account set to pay for every computer from credit. **Computer slots are no longer sold.** Slots you bought before stay on your subscription and add to the 50 until you remove them. Buying one answers `410` with code `slots_retired`.

### Past 50, credit raises the limit

Past the baseline, a new computer is made by the hour from your credit, as long as your credit covers at least an hour of every hourly computer you would then have:

* Your hourly computers at their running rate, or their stopped rate while stopped. One that prepaid its end needs nothing more.
* The new computer's first hour, or its whole prepaid run when it has an end, as described in [Set when a computer ends](https://docs.orgo.ai/guides/computer-ends.md).

Nothing is bought or stored. The limit is worked out at each create, and deleting computers brings you back under the baseline.

* **A plain create goes by the hour on its own.** At the baseline, `POST /api/computers` with no `billing_mode` launches the computer by the hour when your credit covers it. Send `"billing_mode": "hourly"` to ask for that yourself, or `"billing_mode": "plan"` to be refused instead. The launch needs what any launch by the hour needs, described in [Computers by the hour](#computers-by-the-hour): Linux, or Windows where it is offered by the hour, blank or from a starter template, with no `gpu`, image or snapshot.
* **No plan computer is made past the baseline.** A computer that can't run by the hour is refused there: a clone, a fork, a restore as a new computer, a move onto the plan, a GPU, macOS, iPhone or Android computer, an image, a snapshot, or a template that is not a starter. Switching an hourly computer onto the plan is refused too, and it stays by the hour.
* **Only the workspace owner raises it.** A member past the baseline is told to ask the owner, and the owner's credit is never read for them.

### The most computers an account can have

The raise by credit never takes an account past 999 computers. An account Orgo gave its own number above 999 can have up to that number, at most 9999, and credit does not raise it further. At that point a create answers `403` with code `VM_SLOT_ADDON` and `upgradeTier: "enterprise"`: `999 computers is the most an account can have. Delete one, or contact us for more.` An account already past it keeps its computers. Only new ones are refused.

### What counts toward the limit

* Every computer in every workspace you own, plan or hourly, whatever its state: running, stopped, suspended or asleep in storage.
* A device (an iPhone, an Android phone, or a Mac you connect) counts as 1 computer and uses none of the pools.
* A macOS computer counts as 1 computer and takes 10 GB of the RAM pool. Its vCPU comes from its Mac host, not from your pool.

These do not count:

* **Computers in a workspace a client pays for** under [Invoicing](https://docs.orgo.ai/guides/invoicing.md). Instead, that workspace can't cost more a month than the client pays: a create or resize past it answers `403` with code `CLIENT_PRICE_EXCEEDED`.
* **Bops computers** and **template test runs**.

Deleting a computer frees its place at once. The count is checked when a computer is added: create, clone, fork, restore as a new computer, and switching an hourly computer onto the plan. Starting, waking or resuming a computer you already have is never refused for the count.

### What a refusal at the limit says

At the limit, a create answers `403` with code `VM_SLOT_ADDON`. A negotiated plan at its computer count answers code `PLAN_LIMIT` instead. Both carry these fields beside `error`, `code` and `upgradeTier: "enterprise"`:

| Field | Meaning |
| - | - |
| `computers` | Every computer the account has now, plan and hourly. |
| `limit` | The baseline. Past it, new computers run by the hour from credit. |
| `ceiling` | The most the account can have: 999, or its own number when that is higher. |
| `credit_usd_needed` | How many more dollars of credit the raise needs, rounded up to the cent. `0` when the credit covers it. Absent when the credit was not read, such as for a member. |
| `raise_available` | On a plan create past the baseline: whether this computer could run by the hour here at all. `false` means credit does not help: delete a computer, or contact us. |
| `max_computers`, `computers_used` | The same numbers as `limit` and `computers`, kept for older clients. |

The one free computer on signup credit answers `403` with code `HOURLY_LIMIT`, and its body carries only `error` and `code`.

The `error` says what to do:

| When | `error` |
| - | - |
| Past the baseline, and the credit is short | `You have 50 computers. To make more, add credit: computers past 50 run by the hour from your credit, and you need at least an hour of credit for all of them (about $0.06 more).` The amount is `credit_usd_needed`. |
| Past the baseline, the credit covers it, and the create asked for the plan | `You have 50 computers. Computers past 50 run by the hour from your credit, so launch this one by the hour.` |
| A copy past the baseline | `You have 50 computers. Computers past 50 run by the hour, and copies cannot. Delete one, or contact us for more.` |
| A member past the baseline | `This account has 50 computers. Computers past 50 run by the hour from the owner’s credit, so ask the owner to launch one.` |
| At the most an account can have | `999 computers is the most an account can have. Delete one, or contact us for more.` |
| The one free computer on signup credit (`HOURLY_LIMIT`) | `A free account can have 1 computer. Delete it, or add credit or choose a plan for more.` |
| A negotiated plan (`PLAN_LIMIT`), when its account can't launch by the hour | `Your plan allows N computers, and you have M. Delete one, or contact us to change your plan.` |

### See where you stand

* **`GET /api/billing/quota`** returns `computers` (every computer, plan and hourly), `baseline` (`null` when the account has no limit), `ceiling`, `can_raise` and `raise_available`. `can_raise` is `true` when your credit covers going past the baseline now, for a Medium Linux computer by the hour, and `null` when the credit could not be read. `raise_available` is `false` when credit can't raise your limit at all.
* **[Get capacity](https://docs.orgo.ai/api-reference/account/capacity.md)** returns the same under `computers`, as `total`, `baseline`, `ceiling`, `can_raise` and `raise_available`, beside `limit` and `in_use`, which count your plan computers alone.

### When credit runs out

An hourly computer is billed by the second from your credit. When the credit can't pay for the next minute, the computer stops. Adding credit does not restart it: start it again, which needs credit (`402`, code `INSUFFICIENT_COMPUTE_CREDIT`: `Add credit to start this computer.`). A launch without enough credit answers `402` with code `insufficient_credit`. Your plan's monthly AI credit does not pay for hourly computers.

An end you give a computer is 1 to 720 hours, and the computer is deleted when it is up, as described in [Set when a computer ends](https://docs.orgo.ai/guides/computer-ends.md).

### Computers by the hour

* **On a paid plan, a computer runs by the hour when your plan has no room for its vCPU, RAM or disk, and every computer past the baseline does.** A launch by the hour that fits the plan answers `409` with code `FITS_PLAN`. [How a computer is paid for](https://docs.orgo.ai/guides/billing.md#how-a-computer-is-paid-for) explains when each applies.
* **Free runs Medium Linux computers.** Any other size answers `403` with code `FREE_HOURLY_MEDIUM_ONLY`: `Free accounts can launch a Medium computer. Choose a plan for other sizes.`
* **Free on signup credit alone runs one computer**, and free computers on signup credit share running places across all free accounts. When they are full, a launch or a Start answers `503` with code `FREE_HOURLY_BUSY`: `Free computers are busy right now. Try again in a few minutes.` Buying credit or choosing a plan lifts both.
* **Only the workspace owner launches by the hour.** On a paid plan, that means signed in, or with a key that has full access or Billing write.

## Workspaces, people and keys

### Workspaces

You can own 9999 workspaces on every plan, Enterprise included. At 9999, a new workspace answers `403` with code `WORKSPACE_LIMIT`: `An account can have up to 9999 workspaces. Delete one, or contact us for more.` A workspace name is 1 to 80 characters and unique among your workspaces, ignoring case. A name you already use answers `400` with code `WORKSPACE_NAME_TAKEN`.

### People per workspace

Each Orgo workspace holds the number of people in [Limits by plan](#limits-by-plan), besides its owner, counted against the owner's plan. A Bops workspace follows its owner's Bops plan instead: 0 on Free, 2 on Pro, 10 on Max.

* Members, share-link guests and invites that haven't expired all count.
* An invite expires after 7 days. A share link lasts 30 minutes, and each person who joins with it needs a free seat at that moment.
* Only the owner can invite people or make a share link.
* Accounts that pay Orgo for dedicated computers or hardware can have 25 people per workspace, or their plan's number if that is higher.
* People already in a workspace keep their access if the plan goes down. A lower plan only stops new people joining.

At the limit, an invite answers `403` with code `SEAT_LIMIT`, carrying `limit`, `used` and `upgradeTier`. On Free, it answers `403` with code `UPGRADE_REQUIRED`. More is in [Workspaces, members and clients](https://docs.orgo.ai/guides/workspaces-and-clients.md).

### Make someone else the owner

The new owner's account must have room for the workspace's computers, RAM and vCPU on top of their own. Their computers count plan and hourly together, against their baseline. Otherwise the change answers `409` with code `NEW_OWNER_CAPACITY`, for example `Their account includes 50 computers, and this would bring them to 54.` A workspace that has hourly computers can't change owner (`409`, code `HOURLY_COMPUTERS`).

### API keys

* No limit on how many keys an account has.
* 30 key creates or changes an hour, described in [Rate limits](#rate-limits).
* An expiry is optional: 1 to 365 days. See [Key expiry and rotation](https://docs.orgo.ai/api-reference/api-keys/expiry-and-rotation.md).

### Secrets

* No limit on how many secrets you store.
* A name is up to 64 letters, digits, `_` and `-`. A value is up to 8,192 characters.
* One [Apply secrets](https://docs.orgo.ai/api-reference/secrets/apply.md) call takes 1 to 50 names and 1 to 100 computers. Values too large to send in one call answer `413` with code `too_large`. Apply fewer at a time.

### Client accounts

Each client account is a workspace you own, kept out of your workspace list. It can have its own `max_computers` (0 to 10,000) and `monthly_ai_cap_usd` ($0 to $1,000,000), or no limit, as described in [Add a client](https://docs.orgo.ai/api-reference/clients/create.md).

* A client at its computer limit answers `403` with code `ACCOUNT_COMPUTER_LIMIT`: `This account is limited to N computers. Raise max_computers to add another.`
* A client at its monthly AI limit answers `402` with code `account_ai_limit`.

An invoice is 50 cents to \$100,000, with 1 to 10 line items and up to 20 metadata keys, due within 365 days (30 by default). See [Invoicing](https://docs.orgo.ai/guides/invoicing.md).

## How big one computer can be

The sizes and the values the API accepts are in [Instance types](https://docs.orgo.ai/guides/instance-types.md).

* **On your own, up to XL: 6 vCPU and 32 GB RAM.** Past that (2XL: 8 vCPU, 64 GB) is set up on request. A larger create answers `403` with code `CONTACT_US_FOR_SIZE`: `Computers larger than 6 vCPU and 32 GB are set up on request. Contact us.`
* **No computer goes above 8 vCPU, 64 GB RAM or 300 GB of disk**, on any plan. A request for 16 vCPU answers `403` with code `PER_COMPUTER_CPU_CAP`.
* **Each computer also comes out of your pool.** One computer can take as much of it as is free. A computer with more RAM than your whole RAM pool plus the RAM you bought answers `403` with code `RAM_ADDON`: `This size needs N GB of memory. Your plan allows M GB per computer.` A computer that fits the pool's size but not what is left free answers `403` with code `RAM_ADDON` (`You have N GB of memory free. This size needs M GB.`) or `VCPU_ADDON` (`You have N vCPU free. This size needs M.`). On a paid plan, the workspace owner can launch either one by the hour instead.

### Disk

* A new computer on a current paid plan gets 40 GB, unless you choose a size or its template sets one.
* The most one computer can have before add-ons is in [Limits by plan](#limits-by-plan). Storage add-ons raise it, up to 300 GB per computer. Your storage blocks are shared by all your computers.
* Above the ceiling, a create answers `400` with code `disk_exceeds_quota` and `max_disk_gb`. A resize answers `400` with the same message and `max_disk_gb`.
* **Disk only grows.** A resize below the current size answers `400`: `Storage can only be increased (current: N GB)`.

### Resize

[Resize](https://docs.orgo.ai/api-reference/computers/resize.md) changes a computer within the same limits, with these on top:

* Only a running computer resizes, and one resize runs at a time.
* RAM resizes up to 32 GB on a running computer. 64 GB is reached only at create.
* An hourly computer keeps its size. Launch another size instead.
* Macs, iPhones, Android phones and other devices can't be resized.

### Operating systems

* **Windows** is included on Scale. On Starter and Growth, each Windows computer needs a Windows licence: hold 3 licences, run 3 Windows computers. Without one, a create answers `403` with code `WINDOWS_REQUIRES_SCALE`.
* **macOS** computers have 10 GB of RAM, no more and no less (`400`, code `MACOS_RAM_FIXED`). That is more than Starter's 8 GB pool, so a Mac on Starter needs RAM added. A workspace with no Mac host serving it answers `422` with code `OS_UNAVAILABLE`.

### Bandwidth

A Free account's hourly computer runs at up to 100 Mbps. On a paid plan, [Resize](https://docs.orgo.ai/api-reference/computers/resize.md) sets a computer's bandwidth limit up to 1,000 Mbps.

## Agent runs

These apply to [Chat completions](https://docs.orgo.ai/api-reference/chat/completions.md) (`POST /api/v1/chat/completions`). How many runs an account can start a minute, and have at once, is in [Plan rate limits](#plan-rate-limits).

### Step limit

A step is one model call and the computer actions it makes. A request runs at most 250 steps. Send `max_steps` to allow up to 500.

* A value above 500 runs with 500. A value below 250 runs with 250: `max_steps` can raise the limit but never lower it.
* A value that is not a number is ignored. No value is rejected.
* Each request is a new run, counted from 0. Chat in the Orgo app runs up to 250 steps, or 50 on GPT-6 Astra and GPT-6 Sol.

### When a run reaches its step limit

The run stops and answers `200`, not an error. A response that is not streamed has:

* `finish_reason` set to `"length"` instead of `"stop"`.
* Message content of `Stopped after N steps. Send a message to keep going.`
* `orgo.steps`, the number of steps, and `orgo.thread_id`, the thread the turn was saved to. The thread ID is also sent as the `X-Thread-Id` header.

A streamed response ends with a chunk that carries `finish_reason: "length"`. Its thread ID comes only in the `X-Thread-Id` header.

### Continue a run

1. Add the run's reply to your transcript as an assistant message.
2. Add a new user message, such as `Keep going.`
3. Send the whole transcript again, with the same `thread_id` to keep the saved thread complete.

The new request gets a fresh step limit. The computer's screen and files are where the run left them, but the earlier run's tool calls and screenshots are not returned and can't be sent back.

> [!WARNING]
>
> `thread_id` loads no history. The agent sees only the `messages` you send, and the saved thread is replaced with them plus the new reply. Sending `thread_id` with only `Keep going.` erases the earlier turns from the saved thread. See [Threads and history](https://docs.orgo.ai/api-reference/chat/completions.md#threads-and-history).

### When a run runs out of credit

* **Hold.** Each request holds 10 cents of AI credit before it runs. Without it, the request answers `402` with code `credits_exhausted`.
* **Budget stop.** A run stops once its cost comes within 25 cents of the balance it started with. It answers `200` with `finish_reason` `"stop"`, and the last message says the credit ran out. Add credit and send a follow-up.
* **Member limit.** A request that spends someone else's credit, from a member of your workspace or a share-link guest, may use at most \$5. There is no monthly limit per member. A client account's monthly AI limit applies on top.
* **Your own model key** pays instead of your credit. Your provider's own limits apply, and a request over them answers `429` with code `own_key_rate_limited`. See [Bring your own model key](https://docs.orgo.ai/guides/bring-your-own-key.md).

### Inside a run

* A request body is at most 150 MB. A larger one answers `413` with code `request_too_large`.
* The agent's own shell commands stop after 120 seconds each.

## Computer actions and timeouts

Computer actions made with an API key, a computer's own key or an MCP sign-in count as control calls, described in [Plan rate limits](#plan-rate-limits). Each waits a set time for the computer to answer:

| Endpoint | How long it runs |
| - | - |
| [Bash](https://docs.orgo.ai/api-reference/computers/bash.md) | 200 seconds by default. Set `timeout` from 1 to 300 seconds. |
| [Exec](https://docs.orgo.ai/api-reference/computers/exec.md) | 10 seconds by default. Set `timeout` from 1 to 300 seconds. |
| [Wait](https://docs.orgo.ai/api-reference/computers/wait.md) | Up to 60 seconds. |
| Screenshot, click, type, key, scroll, drag, mouse move | 30 seconds, fixed. |

A tool call from an AI app connected to Orgo's hosted MCP with sign-in stops after 120 seconds, so a longer command fails there. Run it through the API instead.

## Rate limits

API rate limits depend on the plan of the account a request counts against, described in [Plan rate limits](#plan-rate-limits). Some endpoints also have limits of their own, the same on every plan, described in [Endpoint limits](#endpoint-limits).

### Plan rate limits

| What | Free | Starter | Growth | Scale | Enterprise |
| - | - | - | - | - | - |
| New computers a minute | 2 | 10 | 30 | 60 | Custom |
| New computers an hour | 10 | 100 | 300 | 1,000 | Custom |
| New computers a day | 20 | 500 | 2,000 | 5,000 | Custom |
| Starts, stops and other changes a minute | 10 | 60 | 120 | 300 | Custom |
| Starts, stops and other changes to one computer a minute | 10 | 10 | 10 | 10 | Custom |
| Control calls a minute | 300 | 1,500 | 3,000 | 6,000 | Custom |
| Control calls to one computer a minute | 600 | 600 | 600 | 600 | Custom |
| Agent runs a minute | 5 | 30 | 60 | 120 | Custom |
| Agent runs at once | 1 | 5 | 20 | 50 | Custom |
| New workspaces an hour | 10 | 30 | 60 | 120 | Custom |
| Other API calls a minute | 120 | 600 | 1,200 | 3,000 | Custom |

What each row counts:

* **New computers**: every way a computer is made. That is [Create computer](https://docs.orgo.ai/api-reference/computers/create.md), creating one by workspace name, [Clone](https://docs.orgo.ai/api-reference/computers/clone.md), [Fork](https://docs.orgo.ai/api-reference/computers/fork.md), a restore as a new computer, a template preview, Build and launch, the computer made during onboarding, and a free trial computer. On create, clone and fork the count comes just before the computer is made, so a request refused for its body, its plan or the computer limit spends none.
* **Starts, stops and other changes**: [Start](https://docs.orgo.ai/api-reference/computers/start.md), [Stop](https://docs.orgo.ai/api-reference/computers/stop.md), [Restart](https://docs.orgo.ai/api-reference/computers/restart.md), [Resume](https://docs.orgo.ai/api-reference/computers/resume.md), [Suspend](https://docs.orgo.ai/api-reference/computers/suspend.md), [Delete](https://docs.orgo.ai/api-reference/computers/delete.md), [Resize](https://docs.orgo.ai/api-reference/computers/resize.md), a restore in place, and the other changes that boot, stop or rebuild a computer.
* **Control calls**: screenshot, click, drag, mouse move, scroll, type, key, bash, exec and wait, calls through the Desktop API proxy, and terminal input over the WebSocket. Only API keys, a computer's own key or identity token, and MCP sign-ins are counted.
* **Agent runs**: [Chat completions](https://docs.orgo.ai/api-reference/chat/completions.md). A run holds its place at once until it finishes.
* **New workspaces**: [Create workspace](https://docs.orgo.ai/api-reference/workspaces/create.md).
* **Other API calls**: every other request from an API key, a computer's own key or an MCP sign-in.

Who is counted:

* **Per account, never per key.** A request on a computer or a workspace counts against the account that owns it, the workspace owner. Any other request counts against your own account. Extra keys share their account's numbers.
* **Signed in use of the dashboard is never counted** for control calls or other API calls. New computers, starts and stops, and new workspaces count from the dashboard too. Agent runs count only requests to Chat completions. The dashboard's own agent chat is not counted as an agent run.
* **Plans no longer sold** count as the nearest current plan: Starter (20 GB) and Developer as Starter, Team and Growth (200 GB) as Growth, Scale (200 GB) and Max as Scale. A paid Bops plan counts as Starter at least. An account Orgo has set to pay for every computer from credit starts from the Scale numbers. Orgo can also set an account's own numbers.
* **Windows are fixed**: a minute, a clock hour, and a day that ends at 00:00 UTC.
* **Control calls and other API calls are counted on each Orgo server separately**, so requests spread over several servers can get past the number. Plan for the number listed.

Over a limit, the request answers `429` with code `rate_limited`. `limit` names the limit that was reached, and `retry_after` is how many seconds to wait:

```json theme={null}
{
  "error": "Too many new computers this minute (2 a minute on your plan). Try again in 41 seconds.",
  "code": "rate_limited",
  "limit": "computer_create_per_minute",
  "retry_after": 41
}
```

* **Headers.** The `429` carries `Retry-After`, and `RateLimit-Limit`, `RateLimit-Remaining` and `RateLimit-Reset` for the limit with the fewest requests left. Answers that are not refused carry the `RateLimit` headers too.
* **Agent runs at once** say `1 agent run at once is the most on your plan. Try again when one finishes.`
* **Your account's own numbers** say `for this account` in place of `on your plan`.
* **Chat completions** answers in its own error shape: `{ "error": { "type": "rate_limit_error", "message": "…", "code": "rate_limited", "limit": "chat_runs_per_minute", "retry_after": 12 } }`.

Wait `Retry-After` seconds, then retry.

### Endpoint limits

The endpoints in the tables below have limits of their own, the same on every plan. Most answer `429` with code `rate_limited` and a `Retry-After` header, and many also carry `retry_after` in the body:

```json theme={null}
{ "error": "Too many new keys this hour. Try again later.", "code": "rate_limited", "retry_after": 1740 }
```

Wait that many seconds, then retry. An hour is a clock hour and a day ends at 00:00 UTC, unless a row says rolling. Some limits are counted on each Orgo server separately, so a burst can occasionally get past the number. Plan for the number listed.

### Keys, capacity and billing

| What | Limit | Counted per | Over the limit |
| - | - | - | - |
| Create or change an API key: `POST /api/keys`, `PATCH /api/keys/{id}`, `POST /api/computers/{id}/orgo-key` | 30 an hour, together | Account | `429` `rate_limited`: `Too many new keys this hour. Try again later.` |
| [Get capacity](https://docs.orgo.ai/api-reference/account/capacity.md): `GET /api/account/capacity` | 60 a minute | Account | `429` `rate_limited`: `Too many requests. Try again shortly.` |
| [Add](https://docs.orgo.ai/api-reference/account/add-capacity.md) or [reduce](https://docs.orgo.ai/api-reference/account/reduce-capacity.md) capacity: `POST` and `PATCH /api/account/capacity` | 20 a minute, together | Account | `429` `rate_limited`: `Too many requests. Try again shortly.` |
| Buy credit with the card on file | 10 a minute | Account | `429` `rate_limited` |
| Change auto top-up settings | 10 a minute | Account | `429` `rate_limited` |
| Check a card after adding it | 20 an hour | Account | `429` `rate_limited` |
| Show a secret's value | 30 an hour | Person | `429` `rate_limited`: `Too many keys shown this hour. Try again later.` |
| Auto top-up charges | 5 in any 24 hours, rolling | Account | No error. The next top-up waits. |

### Sign-in

| What | Limit | Counted per | Over the limit |
| - | - | - | - |
| Email sign-in codes | 1 per 30 seconds, 5 per 10 minutes, 10 an hour, rolling | Email address | No `429`. The sign-in page says `You just asked for a code. Use the one we sent, or try again in 30 seconds.` or `You’ve asked for several codes. Use the latest one, or try again later.` |
| Email sign-in codes | 20 an hour; 60 a day | IP address; network | The same messages |
| Two-factor codes | 5 wrong codes lock it for 15 minutes | Account | `429`: `Too many attempts. Try again later.` No `Retry-After`. |
| Confirm a new email address | 5 tries per change in 15 minutes; 20 an hour | Email change; account | `429`: `Too many tries. Start again for a new code.` |
| [Device sign-in](https://docs.orgo.ai/for-agents.md#get-an-api-key-with-device-approval) start: `POST /api/cli/auth/start` | 20 an hour | IP address | `429` `rate_limited`: `Too many sign-in requests from this network. Try again later.` |
| Device sign-in poll: `POST /api/cli/auth/poll` | 40 a minute; 1,200 an hour | Device code; IP address | `429` `rate_limited`: `Polling too fast. Wait, then poll again.` |
| Connect an AI app to Orgo's MCP with sign-in | Authorize 20, consent 30, register 10, token 60, revoke 60, each a minute | IP address | `429` `temporarily_unavailable`: `Too many requests. Try again in a minute.` No `Retry-After`. |

An email code works for 10 minutes, and 5 wrong guesses end it. A device sign-in code expires after 10 minutes. An MCP sign-in's access token lasts 1 hour, and its grant 30 days.

### Support and contact

| What | Limit | Counted per | Over the limit |
| - | - | - | - |
| [Ask support](https://docs.orgo.ai/api-reference/support/ask.md) and the help panel, signed in | 30 questions an hour; 2 at once | Account | `429` `rate_limited`, or `429` `one_at_a_time`: `One question at a time. Wait for the answer, then ask again.` |
| Ask support, not signed in | 15 an hour and 40 a day; 160 a day | IP address; network | `429` `rate_limited` |
| Talk to a person | 3 requests an hour; 12 a day | Account, or IP address when not signed in; network | `429` `rate_limited`, no `Retry-After` |
| Add to a request to a person | 20 an hour per request; 60 an hour | Request; account (30 per IP address when not signed in) | `429` `rate_limited`, no `Retry-After` |
| Contact us or contact sales | 5 an hour | Account, or IP address when not signed in | `429` `rate_limited` |

Each account gets 150,000 free support tokens a day. After that, answers come out of your credits, as described in [Ask support](https://docs.orgo.ai/api-reference/support/ask.md).

### Agents and models

| What | Limit | Counted per | Over the limit |
| - | - | - | - |
| An agent on a computer calling Orgo's model gateway with the computer's own key | 8 requests at once | Computer | `429` `rate_limit_error`: `Too many requests from this computer at once.` with `retry-after: 2` |
| The same gateway, when other requests are holding the credit | | Workspace | `429` `rate_limit_error`: `Other requests from this workspace are holding its credits right now. Try again in a moment.` with `retry-after: 5` |
| The workspace agent in the Orgo app | 30 tool calls a minute, rolling | Computer in a workspace | No HTTP error. The agent is told to wait before its next call. |
| Your own model key on Chat completions | Your provider's limits | Your key | `429` `own_key_rate_limited` |

One gateway request runs for at most 40 minutes, with a body of at most 32 MB.

### Templates

| What | Limit | Counted per | Over the limit |
| - | - | - | - |
| [Publish](https://docs.orgo.ai/api-reference/templates/publish.md) | 10 in a burst, then 1 a second | Account | `429` `publish_rate_limited` |
| [Validate](https://docs.orgo.ai/api-reference/templates/validate.md) | 60 in a burst, then 10 a second | Account | `429` `validate_rate_limited` |
| [Build](https://docs.orgo.ai/api-reference/templates/build.md) | 3 in a burst, then 1 a second; 10 queued or running | Account | `429` `build_rate_limited`, or `429`: `you already have 10 builds queued or running (limit 10); wait for one to finish` |
| [Test run](https://docs.orgo.ai/api-reference/templates/test-run.md) | 5 in a burst, then 1 a second; 5 test computers at once | Account | `429` `vm_rate_limited` or `tenant_vm_limit` |
| Templates stored | 100 | Account | `429` `tenant_quota_exceeded` |

### Screens

A VNC WebSocket message is at most 16 MB. A larger one closes the connection.

## One operation at a time

Some changes run one at a time. A request that arrives while one is under way is refused and changes nothing, unless it repeats the same Start or Stop.

| While | A second request answers | Retry |
| - | - | - |
| A [Start](https://docs.orgo.ai/api-reference/computers/start.md), [Stop](https://docs.orgo.ai/api-reference/computers/stop.md) or restore from a backup runs on the computer | The same action joins it: `202` with `poll_url`. A different action: `409` `OPERATION_IN_PROGRESS`. | `Retry-After: 2` on the `202` |
| The previous operation was interrupted | `409` `OPERATION_NEEDS_REVIEW`: `The previous operation was interrupted and is being checked. Try again in a few minutes.` | A few minutes |
| A [Resize](https://docs.orgo.ai/api-reference/computers/resize.md) runs | `409` `RESIZE_IN_PROGRESS`: `This computer is already being resized. Try again when it finishes.` | `Retry-After: 30` |
| The computer's host is starting, restarting or saving it | `409` `COMPUTER_BUSY` on a resize | `Retry-After: 30` |
| The computer wakes from storage | An action waits up to 150 seconds, then `409` `computer_waking`: `This computer is waking up. Try again in a minute.` | `Retry-After: 30` |
| The computer resumes | `503` `resuming` | `Retry-After: 30` |
| A suspend is still saving | `409` `suspend_in_progress` | |
| The computer woke moments ago | `409` `converging` on a suspend | `Retry-After: 30` |
| The computer moves to another host | `409` `migrating`: `This computer is being moved to another host. Try again in a few minutes.` | A few minutes |
| An operation runs, and you change the computer's end | `409` `COMPUTER_BUSY` with `retryable: true` | A minute |
| An SSH key change runs | `409` `ssh_change_in_progress` | |
| The computer's VNC password changes | `503` `vnc_rotation_pending` on [VNC password](https://docs.orgo.ai/api-reference/computers/vnc-password.md) | `Retry-After: 30` |
| The computer's own key is busy | `503` `copy_key_busy` on [Clone](https://docs.orgo.ai/api-reference/computers/clone.md), [Fork](https://docs.orgo.ai/api-reference/computers/fork.md) or restore as new | |
| Another charge for the account is going through | `409` `billing_busy`: `Another charge for this account is going through. Try again in a minute.` Nothing is charged. | A minute, no `Retry-After` |
| A request with the same `Idempotency-Key` is still running | `409` `idempotency_in_progress` | A few seconds, no `Retry-After` |

## Request sizes

| Request | Most | Larger |
| - | - | - |
| Most endpoints | 10 MB body | Cut off, so the endpoint usually answers `400` for invalid JSON |
| [Chat completions](https://docs.orgo.ai/api-reference/chat/completions.md) | 150 MB | `413` `request_too_large` |
| [Upload file](https://docs.orgo.ai/api-reference/files/upload.md) | 10 MB per file | `400`: `File too large (max 10MB)` |
| [Start large upload](https://docs.orgo.ai/api-reference/files/start-upload.md) and [Export](https://docs.orgo.ai/api-reference/files/export.md) | 2 GB per file | `413`: `File is N bytes; the limit is 2147483648. Split or compress it first.` |
| [Ask support](https://docs.orgo.ai/api-reference/support/ask.md) | 3 images of 5 MB each | `413` `request_too_large` |
| Public keys on [Turn on SSH](https://docs.orgo.ai/api-reference/computers/ssh-enable.md) | 16 KB | `400`: `public_key too large (max 16 KB)` |
| Contact us message | 4,000 characters | `400` `message_too_long` |

A large upload's signed URL works for 15 minutes. An export's download link works for 1 hour.

## What happens at a limit

| Limit | Answer | What to do |
| - | - | - |
| Computers per account | `403` `VM_SLOT_ADDON`, with `computers`, `limit`, `ceiling` and `credit_usd_needed` | Past the baseline, add credit and launch it by the hour. At the most an account can have, delete a computer or contact us |
| RAM pool, or RAM for one computer | `403` `RAM_ADDON` | Add RAM, shrink or delete a computer, or launch it by the hour |
| vCPU pool | `403` `VCPU_ADDON` | Add vCPU, shrink or delete a computer, or launch it by the hour |
| Disk per computer | `400` `disk_exceeds_quota` | Add storage, up to 300 GB per computer |
| Larger than XL | `403` `CONTACT_US_FOR_SIZE` | Contact us |
| More than 8 vCPU | `403` `PER_COMPUTER_CPU_CAP` | No plan goes higher |
| A plan computer on Free | `403` `UPGRADE_REQUIRED` | Choose a plan, or launch it by the hour |
| Free's one computer on signup credit | `403` `HOURLY_LIMIT` | Delete it, add credit, or choose a plan |
| Windows on Starter or Growth | `403` `WINDOWS_REQUIRES_SCALE` | Add a Windows licence, or move to Scale |
| Workspaces | `403` `WORKSPACE_LIMIT` | Delete a workspace, or contact us |
| People per workspace | `403` `SEAT_LIMIT` | Remove someone, or choose a bigger plan |
| A negotiated plan's limit | `403` `PLAN_LIMIT` | Contact us to change your plan |
| Add-on amounts | `403` `capacity_cap` | Contact us |
| A client's computers | `403` `ACCOUNT_COMPUTER_LIMIT` | Raise the client's `max_computers` |
| AI credit | `402` `credits_exhausted` | Add credit |
| Hourly credit | `402` `insufficient_credit` or `INSUFFICIENT_COMPUTE_CREDIT` | Add credit, then launch or start it |
| A plan rate limit | `429` `rate_limited`, with `limit` and `retry_after` | Wait `Retry-After` seconds |
| An endpoint's own rate limit | `429` | Wait `Retry-After` seconds, when it is sent |

An owner on Free can't start a plan computer at all: Start answers `402` with code `upgrade_required`: `Your plan does not include running computers. Upgrade to start this computer.`

## Ask for more

A refusal that carries `upgradeTier: "enterprise"`, or a dashboard that shows **Contact us**, means no self-serve plan goes higher. A `VM_SLOT_ADDON` refusal with `credit_usd_needed` above `0` is the exception: add that much credit, and the computer can run by the hour. [Email us](mailto:contact@orgo.ai) with what you need: more than 999 computers, larger pools, computers past XL, or more people per workspace. Enterprise sets these per account. Rate limits rise with the plan, and Orgo can set an account's own. If one gets in your way, tell us that too.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.