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

# Limits

> Every limit the API enforces.

Sizes are binary: 1 MB is 1,048,576 bytes.

| Limit | Value |
| - | - |
| Document id | 128 bytes of `A-Z a-z 0-9 . _ : / -`, never exactly `.` or `..` |
| Document state | 1 MB |
| Attributes per document | 64 |
| Documents per write | 1,000 or 64 MB |
| A written document's `created_at` | at most 5 minutes in the future, and not before 1970 |
| Judgments per namespace | 100 active |
| [Subscriptions](/concepts/subscriptions) per namespace | 100 created, on every plan, counting those it inherits from a template; subscriptions its template gains later can take it past that |
| Fields per subscription | 24 attributes and answers, counting those its filter reads and its `include` |
| Versions per judgment | unlimited, kept until the namespace is deleted |
| Choice options | 254 plus the injected escape option |
| Score levels | 2 to 10 |
| Compiled context | the engine's limit (jev current: 32,000 tokens), or `max_tokens` if lower |
| Questions per engine request | 32 |
| `top_k` | 1,000 |
| Namespaces per organization | unlimited |
| Namespace name | 256 bytes |
| [Non-production prefixes](/guides/staging-environments) | 20 marked at once per organization, and 100 markings counted at once, each while marked and for 90 days after it is unmarked |
| Periodic `interval` | at least 1 hour: each run re-judges the whole namespace |
| [Outcome rules](/guides/measure-improve-tune#outcomes-from-your-own-data) per judgment | 4, each on one path, with at most 16 values in `in`; they apply to writes from when they are set |
| [Labelling-queue](/guides/measure-improve-tune#label-a-random-sample) draw | 1 to 200 documents (default 50) from 10 probability bands, leased for 7 days; a label's `queue_item_id` is accepted while the lease holds |
| [Recipe tuning](/guides/measure-improve-tune#let-your-outcomes-tune-the-recipe) | one run per judgment version, engine epoch and month |
| [Suggested recipe](/guides/context-recipes#when-you-leave-out-context) | `max_tokens` at most 2,000 less the question's tokens, so context and question stay in the [standard size class](/pricing#judgments); `excluded` says what was left out and why |
| `default/quickstart` | 10,000 documents and 100 MB; a write past that is refused with `too_large`. It is free, and its judging pauses for the rest of the [billing period](/pricing#billing-periods) at [its usage limit](/pricing#quickstart) |
| Unpaid usage before your first charge | judging pauses at \$500 of unpaid usage until your first charge, or a [year paid up front](/pricing#paying-annually), goes through; see [how you are charged](/pricing#how-you-are-charged) |
| [Evaluation history export](/guides/export-history) | at most 366 days per export (the last 30 days by default), in files of up to 100,000 evaluations, at most 1,000 files; files are deleted 7 days after they are written, and each download link works for 1 hour |

## Relations

For judgments that read other documents through [relations](/concepts/relations). A request over any of these is refused with `invalid_request`.

| Limit | Value |
| - | - |
| Keys in `applies_to` and in each relation's `match` | 8 each |
| Relations per judgment | 4, each with a `last_n`, a `window` or both, except one that reads a [referenced document](/guides/referenced-document), which takes neither, and a blocking one, which needs a `window` |
| `last_n` on a relation | 1,000; 254 on a blocking relation, and 10 on one a choice picks among with `options.from` |
| Judgments whose answers one relation reads | 4; their paths count toward the relation's aggregate paths. A probability or score renders only as a band |
| A relation that selects by an answer in `match` | reads at most 4 × its `last_n` (or 4,000 without one) of the newest documents that match on attributes, and shows `capped: true` when it stops there |
| Related documents a relation reads | the newest 1,000 created, whatever its `last_n` and `window`; one for a referenced document |
| Aggregate paths per relation | 8 across `sum`, `min`, `max` and `latest` |
| Bands on a field | 1 to 9 strictly increasing cut points, and one more label, each label up to 64 bytes |
| Features per composite judgment | 8 |
| Reference indexes per namespace | 8, one per attribute that relations key on, whether related documents point through it or judged documents do, counting judgments inherited from a template; an attribute used several ways is one index, and one more is refused and `details.reference_indexes` names the current ones |
| Groups per namespace | 8, counting inherited ones, each with at most 1,000 live key values and 8 aggregate paths. A key value stays live for 90 days after its newest document by default (`keep_keys`), and a group's rows are at most about 1 hour behind your writes |
| `discover` | up to 10 proposed options (5 by default), from a sample of the escaped documents of the last 7 days by default; 10 calls per organization a day, apart from `suggest_parts`' calls; past them, `rate_limited` with `details.limit` and `details.resets_at`, the next midnight UTC |
| `escape_alert` | above 0 and at most 1, or `null` (off); the share of the last 7 days' answers, taken once there are at least 20 |
| `simulate` | up to 1,000 sampled documents (200 by default); the `suggest_parts` daily limits |
| Fan-out settings | `fanout.max_wait_ms` at least `fanout.debounce_ms`; `rolling_limit` 0 or more; `block_cap` 1 or more; the namespace's `share` above 0 and at most 1 |

## Composite judgments

For [composite judgments](/guides/composite-judgments) and their suggested parts.

| Limit | Value |
| - | - |
| Parts per composite judgment | 2 to 8; 1 to 8 with features |
| `suggest_parts` calls | 20 per judgment and 50 per organization a day, across all its namespaces; past either, `rate_limited` with `details.limit` (20 or 50, the limit reached) and `details.resets_at`, the next midnight UTC, and no `Retry-After`. A call that fails with `engine_unavailable` before the model ran does not count; one that timed out does |
| `suggest_parts` `count` | 2 to 8 |
| Labelled examples `suggest_parts` needs | 10 of each answer |

## Fan-out defaults

For judgments that read the document each judged document points at, or the documents that share a key with it: when a change re-judges the judged documents it concerns (the [fan-out](/guides/referenced-document#fan-out)). You confirm the limits once, when you create the judgment; a fan-out past one waits, its answers read `stale`, and it runs when the limit has room. Each is a setting you can change with a `PATCH` and no new version.

| Setting | Default |
| - | - |
| `fanout.scope.created_within` | 30 days: judged documents created longer before the change keep their answer |
| `fanout.scope.where` | none |
| `fanout.debounce_ms` | 600,000 (10 minutes) |
| `fanout.max_wait_ms` | 6 × `fanout.debounce_ms`, so 3,600,000 |
| `fanout.rolling_limit` | 300,000 judged documents re-judged by changes to referenced documents and blocks in any 30 days; `null` for no limit |
| `fanout.block_cap` | 1,000 judged documents per key value of a blocking relation |
| Namespace `fanout.share` | 0.5 of the namespace's in-flight engine requests, always at least one |

## Requests

| Limit | Value |
| - | - |
| Estimated query scan | 4 GB; larger queries are refused with `too_large` and are not billed |
| `wait_ms` on a get | 10,000 ms |
| `wait_timeout_ms` on a write | 10,000 ms; a larger value is lowered to it |
| Documents of one write judged at interactive priority | the first 16; the rest are judged with ordinary catch-up, so a large `wait_for` write usually returns them `pending` |
| Query cursor validity | 10 minutes |
| Requests per key | 1,000 per second by default; `X-RateLimit-Limit` and `X-RateLimit-Remaining` count against this |
| Reads in flight per namespace | 32 gets and queries of one namespace at once, from all your keys together. One more is refused with `rate_limited`, `Retry-After: 1` and `details.concurrent_reads` (the limit), whatever the rate-limit headers show; retry it, as the SDKs do. Spread reads over time, or over namespaces, to stay under it |
| Namespace size in v1 | designed for up to 100,000,000 documents or 256 GB. This is the design ceiling, not an enforced limit: a larger namespace is accepted, but its performance is not measured |


## Related topics

- [judgment.limit_reached](/api-reference/webhooks/judgmentlimit_reached.md)
- [Subscriptions](/concepts/subscriptions.md)
- [Report on groups of documents](/guides/groups.md)
- [jev current](/engines/jev-current.md)
- [Discover new options](/guides/discovery.md)


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