Quotas
A project has four quotas: ceilings that keep one project from filling the beta for everybody else. They are the same on every plan and are counted per project — a second project starts with all four empty, and one project’s CI cannot spend another’s.
A quota stops writes only. Reading is never refused: a project over a quota can still open, read and delete what put it there.
The limits of your plan — how many projects, how many people — are a separate list, under Plan & usage on the Account page. This page is about the four quotas.
The four quotas
Section titled “The four quotas”| Quota | Limit | What is counted | What frees a place |
|---|---|---|---|
runsPerDay | 1,000 | Runs opened in the last 24 hours, however they arrived — a reporter, the CLI, a plan’s launch, a manual run | Time. The window is rolling, not a calendar day: a run stops counting 24 hours after it was opened |
testCasesPerProject | 20,000 | Live test cases. Cases in the Bin are not counted | Deleting cases, or an operator raising the limit |
bugsPerProject | 5,000 | Live bugs. Bugs in the Bin are not counted | Moving bugs to the Bin |
pendingReviewItems | 1,000 | Items waiting in the review queue. Approved and rejected items are history and are not counted | Approving or rejecting what waits |
The count a screen shows is the count a write is judged by: both come from the same place.
Where you see what is left
Section titled “Where you see what is left”- Test cases — a bar under the head of the screen, with Test cases in this project: ‹used› of ‹limit› used, ‹left› left. It appears only once 80 % of the limit is used — from 16,000 cases at the limit of 20,000. Below that the screen shows nothing.
- Launching a run — the dialogs that start a run from a plan or from the cases (Launch a run
from a plan, Manual run, Run manually… in the tree’s
⋯) show the bar of Runs in the last 24 hours, at any level. Re-run N failed, Launch a copy and Clone with a filter on a run’s page show no bar, though a run they start counts against the same quota. - Review — the queue’s screen shows the bar of Items waiting in the review queue under its filters, at any level.
- Bugs — no bar. When the project holds as many bugs as it may, a person who can write sees This project holds 5,000 bugs, the most one project may keep. Move closed bugs to the Bin to create new ones. on the Bugs list; Bugs → Limits.
When a quota is spent, the bar says why after the figures:
| Quota | The bar adds |
|---|---|
| Runs | New runs are refused until the oldest ones age out of the 24-hour window. and A slot frees at the date and time the oldest run ages out |
| Test cases | New cases are refused until some are deleted or an operator raises the limit. |
| Review queue | New proposals are refused until the queue is worked down. |
If the quotas cannot be read, the bar is not drawn; the screen works as usual.
The API
Section titled “The API”GET /v1/quotas{ "quotas": { "runsPerDay": { "limit": 1000, "used": 42, "remaining": 958, "resetsAt": "2026-11-04T09:12:00.000Z" }, "testCasesPerProject": { "limit": 20000, "used": 1204, "remaining": 18796, "resetsAt": null }, "bugsPerProject": { "limit": 5000, "used": 17, "remaining": 4983, "resetsAt": null }, "pendingReviewItems": { "limit": 1000, "used": 3, "remaining": 997, "resetsAt": null } }}remaining is limit - used and never goes below 0. resetsAt is when a place frees by itself:
the moment the oldest run of the window turns 24 hours old. The other three free only by an action,
so theirs is null. Any member of the project may read it, a reader too.
The refusal: 429
Section titled “The refusal: 429”A write that would go over a quota is refused with 429, and nothing of it is written (one batch
can stop part way, below). The body is the sentence and the figures behind it:
{ "error": "test case quota reached — at most 20000 cases per project. Delete cases you no longer need, or ask an operator to raise the limit.", "quota": { "kind": "testCasesPerProject", "limit": 20000, "used": 20000, "remaining": 0, "resetsAt": null }}There is no code field. The quota object marks a refusal as a quota, and its kind says which
one; a 429 of any of the four quotas carries it. A Markdown push adds
to the case quota’s sentence how many new cases the document makes, and a
file import has a sentence of its own. The sentences, word
for word:
kind | error |
|---|---|
runsPerDay | run quota reached — at most 1000 runs per 24h. The window is rolling, so the oldest runs free up slots as they age out; ask an operator to raise the limit if this is normal traffic. |
testCasesPerProject | test case quota reached — at most 20000 cases per project. Delete cases you no longer need, or ask an operator to raise the limit. |
bugsPerProject | bug quota reached — at most 5000 bugs per project. Delete bugs you no longer need, or ask an operator to raise the limit. |
pendingReviewItems | review queue quota reached — at most 1000 items waiting. Approve or reject what is already in the queue to make room. |
Only the run quota’s refusal carries a Retry-After header, in whole seconds until resetsAt. The
other three have nothing to wait for: waiting frees no case, bug or queue place.
A request that writes several at once asks room for all of them: a launch on three environments with
two runs left is refused whole, and no run is made
(Environments). An import of cases has its own check and sentence:
Import → Limits. A batch of discovered tests
(POST /v1/review-items/discovered) asks its room before it writes, but not under the project’s
lock: when another request takes that room in between, it answers this 429 after the cases it had
already made, and those stay; none of the entries it would queue is written, as they come last. The
same batch sent again once there is room makes the rest, and a test that got its case answers known.
Restoring from the Bin
Section titled “Restoring from the Bin”The Bin is not counted, so a case brought back is a new live case as far as the quota goes. Restoring a case, restoring a suite with its cases, or approving a discovered test whose case waits in the Bin is refused with:
Cannot restore: you reached the limit of 20000 test cases per project. Delete cases you no longer need, or ask an operator to raise the limit.The quota object comes with it, and its used counts the live cases, not the ones the restore
would bring back, and remaining is what was left before the restore — so a suite can be refused
while remaining is above 0: there was room, only not for all its cases. A suite comes back whole
or not at all.
Approving in the review queue
Section titled “Approving in the review queue”Approving a proposal or a discovered test makes a test case, so it counts against
testCasesPerProject; approving a disputed result makes none. A single approval
(PATCH /v1/review-items/{id}) over the limit is a 429 with the quota object: the test case
sentence above, or the restore sentence when a discovered test’s case waits in the Bin. The item
stays as it was — it can be approved once there is room.
A decision over a list (POST /v1/review-items/decisions) is not refused whole: it answers 200,
applies what fits, and lists each item it skipped with "reason": "quota_exceeded". On the Review
screen that report reads Did not change:, each skipped item with the project has reached its case
limit, and Repeat over these (N) to try them again once there is room.
What the dashboard says
Section titled “What the dashboard says”The dashboard shows the server’s sentence as the error, word for word apart from a capital first letter, and adds no advice under it: the sentence already says what to do, and wait a moment would be wrong advice for a quota.