Skip to content

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.

QuotaLimitWhat is countedWhat frees a place
runsPerDay1,000Runs opened in the last 24 hours, however they arrived — a reporter, the CLI, a plan’s launch, a manual runTime. The window is rolling, not a calendar day: a run stops counting 24 hours after it was opened
testCasesPerProject20,000Live test cases. Cases in the Bin are not countedDeleting cases, or an operator raising the limit
bugsPerProject5,000Live bugs. Bugs in the Bin are not countedMoving bugs to the Bin
pendingReviewItems1,000Items waiting in the review queue. Approved and rejected items are history and are not countedApproving or rejecting what waits

The count a screen shows is the count a write is judged by: both come from the same place.

  • 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.
The bar of the case quota: Test cases in this project: 16000 of 20000 used, 4000 left. The bar of the case quota: Test cases in this project: 16000 of 20000 used, 4000 left.
The bar appears once 80 % of the case limit is used.

When a quota is spent, the bar says why after the figures:

QuotaThe bar adds
RunsNew 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 casesNew cases are refused until some are deleted or an operator raises the limit.
Review queueNew 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.

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.

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:

kinderror
runsPerDayrun 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.
testCasesPerProjecttest case quota reached — at most 20000 cases per project. Delete cases you no longer need, or ask an operator to raise the limit.
bugsPerProjectbug quota reached — at most 5000 bugs per project. Delete bugs you no longer need, or ask an operator to raise the limit.
pendingReviewItemsreview 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.

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 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.

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.