# UI capture limits and sizes: the SDK's and the server's

> Every size, count, rate and time limit of Keploy UI capture, in the capture SDK and on Keploy's server, and what happens past each one.

Every limit of Keploy UI capture, and what happens past it: first those the capture SDK applies in the browser, for SDK 3.1.0, then those Keploy's server applies. Where a limit is an SDK option you can set, the table names the option and gives its default.

## In the browser {#in-the-browser}

| What                                                        | Limit                                                                                                                | Past it                                                                                                                                                                                                                                                              |
| ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| A recorded body, `maxBodySize`                              | 524,288 UTF-16 code units (512 KB) by default                                                                        | Text is cut and marked `...[truncated]`. Cut JSON is recorded as `[UNPARSEABLE_BODY_NOT_REDACTED]`. A response whose `Content-Length` is larger is not downloaded: `[Response body too large: N bytes]`. See [Large bodies](./network-and-bodies.md#large-bodies).   |
| Events in one request, `batchSize`                          | 50 by default, and at most 5,000 whatever you set                                                                    | The rest go in the next request.                                                                                                                                                                                                                                     |
| One request's size                                          | 10 MiB                                                                                                               | The batch is cut there. An event that is over 10 MiB on its own is dropped, with [`KUI_E_EVENT_OVERSIZED`](./errors.md#kui-e-event-oversized) once per capture.                                                                                                      |
| Time between requests, `batchInterval`                      | 5,000 ms by default                                                                                                  | Each request carries one batch, so a backlog drains one batch at a time.                                                                                                                                                                                             |
| Events held unsent, `maxQueueSize`                          | 5,000 events by default, and 16 MiB                                                                                  | The oldest events are dropped; when a batch that failed to send goes back into a full queue, the newest queued events are dropped instead.                                                                                                                           |
| The last request, as the page unloads                       | 32 KiB: half the 64 KiB of `keepalive` requests a browser lets a page have in flight                                 | What does not fit is lost.                                                                                                                                                                                                                                           |
| Redacting a body on the page's main thread                  | 64 KiB of each body where the page has no body worker; 64 KiB in all as the page leaves or `stop()` ends the capture | The rest of the body is cut, under `[Body cut: K of N characters kept, unverified]`, where `K` is what was kept: 65,536 characters where the page has no worker.                                                                                                     |
| Bodies held for redaction                                   | 8 Mi UTF-16 units (16 MiB) of copies                                                                                 | The next call's bodies are recorded as `[Body cut: 0 of N characters kept, unverified]`.                                                                                                                                                                             |
| A session, `maxSessionDuration`                             | 600,000 ms (10 minutes) by default                                                                                   | The session ends. With `continuous: true`, the next one starts at the visitor's next click, tap or key press.                                                                                                                                                        |
| `stop()` waiting for bodies                                 | 1 second                                                                                                             | A body still open is recorded cut, marked `...[truncated]`.                                                                                                                                                                                                          |
| A request that fails with `429`, a `5xx` or a network error | 3 attempts, up to 1 s and then up to 2 s apart                                                                       | The batch goes back to the front of the queue. Each later batch gets one attempt, after a wait that doubles from 2 s to 60 s, each wait lengthened at random by up to half.                                                                                          |
| A session id from `sessionIdGenerator`                      | 1 to 200 characters of letters, digits, `.`, `-` and `_`, with no empty dot-separated part                           | The capture is refused with [`KUI_E_SESSION_ID_INVALID`](./errors.md#kui-e-session-id-invalid).                                                                                                                                                                      |
| The page's URL, as the SDK reads it for credentials         | 64 KiB of path, query and route, and 32 credential values                                                            | The page's URL is recorded as its origin and `/[REDACTED]`. A credential past those bounds is not held, so a link, a request or a text that carries it again is recorded with it. A value a `privacy.secretRoutes` route names in the URL's own path is always held. |
| Refused `init()` calls, as `onError` hears them             | At most 16 waiting per error code; hand-overs paced from 50 ms, doubling to 30 s                                     | A refusal that comes while 16 wait resolves its `init()` without calling `onError`.                                                                                                                                                                                  |

## On the server {#on-the-server}

These are the limits of Keploy's API server, which Keploy Cloud and a self-hosted Keploy both run.

| What                                  | Limit                                                                                                                                                                                  | Past it                                                                                                               |
| ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| One batch the SDK posts               | 10 MiB, as sent and decoded, and 5,000 events                                                                                                                                          | `413` for the size, `400` for the count. The SDK keeps its batches inside both.                                       |
| Ingest requests                       | 6,000 a minute per ingest key, counted by each Keploy server                                                                                                                           | `429`. The SDK retries on its own backoff.                                                                            |
| One session                           | 256 MiB of events, and 10,000 batches                                                                                                                                                  | `413` with the reason `session_full`: see [When a session ends](./sessions-and-sampling.md#when-a-session-ends).      |
| A session with no new batch           | 30 minutes                                                                                                                                                                             | The server completes the session; it checks every minute. `uiCaptureStatus` reports the window as `idleAfterSeconds`. |
| Extracting a session's flows          | 8 attempts, over about 2 hours                                                                                                                                                         | The session is marked `FAILED`.                                                                                       |
| A revoked key, or a deleted app's key | Up to 30 seconds on each server                                                                                                                                                        | The key is refused with `401`.                                                                                        |
| An ingest key's name                  | 100 characters in the dashboard's box; 100 bytes, spaces at either end trimmed, over the API                                                                                           | Over the API, refused with `400`.                                                                                     |
| An ingest key's lifetime, `ttlDays`   | 1 to 365 days, or no expiry when left out                                                                                                                                              | Refused with `400`.                                                                                                   |
| A key's last use, `lastUsedAt`        | Updated at most once every 5 minutes                                                                                                                                                   |                                                                                                                       |
| The sessions a journey plan reads     | Those of the last 30 days, at most 50,000                                                                                                                                              | The plan reads only the newest, and says so in a note.                                                                |
| A journey plan's reuse                | Up to 24 hours, or until the sessions processed since reach a tenth of those it read (at least one; never for a plan that stopped at 50,000)                                           | The next read computes a new plan.                                                                                    |
| A stored journey plan                 | Kept 14 days                                                                                                                                                                           |                                                                                                                       |
| `uiJourneys` with `refresh=true`      | A new plan at most once a minute per app; it needs `testgen:run` on the app                                                                                                            |                                                                                                                       |
| Journeys selected for testing         | The most taken, until they cover 80% of the moves between pages, and at most 20                                                                                                        |                                                                                                                       |
| `uiFlowGraph` over REST and MCP       | The 100 heaviest links, their nodes (at most 200), and 5 flow ids per link                                                                                                             | What is left out is counted.                                                                                          |
| `listUIFlows`                         | 50 flows a page by default, at most 200                                                                                                                                                |                                                                                                                       |
| `uiCaptureStatus`'s recent sessions   | The 10 most recent                                                                                                                                                                     |                                                                                                                       |
| The REST API, `/client/v1`            | 100 requests a minute per API key, counted by each Keploy server                                                                                                                       | `429`. `X-RateLimit-Limit` shows the limit in force.                                                                  |
| The MCP endpoint, `/client/v1/mcp`    | A request with a Keploy API key (`kep_…`) is not limited there, but each REST call its tools make counts against the key's 100 a minute. Any other request: 60 a minute per IP address | `429`.                                                                                                                |

## Related

- [Sessions and sampling](./sessions-and-sampling.md)
- [Network calls and bodies](./network-and-bodies.md)
- [Ingest keys and environments](./ingest-keys.md)
- [UI Capture errors and warnings](./errors.md)
- [Keploy Public API](../running-keploy/public-api.md)
