> ## Documentation Index > Fetch the complete documentation index at: https://docs.tazolabs.com/llms.txt > Use this file to discover all available pages before exploring further. # Limits > How many requests you can send, and how large each decision request can be. Limits come in two kinds. **API limits** control how much traffic your account can send. **Model input limits** control how large a single decision request can be. Stay inside both and your requests run normally. ## API limits | Limit | Tazo Large | | - | - | | Request rate | 500 requests per rolling minute | | Concurrent requests | 5 | Limits apply per account for each model, shared across all API keys and playground sessions. Concurrency includes accepted requests that are queued, running, or waiting to retry. A timeout or disconnect does not release a durable request's slot; completion does. Matching idempotent retries count once. Requests over either limit return `429` with `Retry-After`. Wait before retrying, using the same `Idempotency-Key`. Each streaming inference evaluation counts as one request; a PCM audio packet does not. Streaming rate errors include retry guidance and close the connection with code 1013. > [!TIP] > > Spread requests out and keep a small queue in your app that never has more > than 5 decisions running at once. Also pace requests to stay within the > separate 500-request rolling-minute limit. ## Streaming limits With the default `audio_scope: "chunk"`, streaming has **no cumulative audio-duration limit**. `session.ready.max_turn_audio_ms` is `null`. Keep sending audio and receiving decisions; commit only when your application needs to end a turn. With explicit `audio_scope: "turn"`, every evaluation includes all audio in the turn, so the model's input limit and server buffer capacity still apply. Read the numeric `session.ready.max_turn_audio_ms`, commit before exceeding it, and wait for `decision.finalized` before sending the next turn. Exceeding that limit returns `turn_too_long` and closes the connection. Packets are limited to 200 ms of source audio. Send at real-time speed; if inference falls behind and pending audio fills the server buffer, the server returns `audio_buffer_full` and closes with code 1013. Account rate limits and timeouts still apply. At the default 1,000 ms evaluation interval, one continuous stream can use 60 requests per minute. Four such streams can use 240 of the account's 500 requests per rolling minute for that model. The remaining capacity is shared with other requests. Actual evaluation frequency also depends on inference speed. See [Streaming decisions](https://docs.tazolabs.com/guides/streaming.md). ## Model input limits These limits describe uploaded decision requests for Tazo Large. Tazo Small is [unavailable through the API](https://docs.tazolabs.com/guides/models.md). Streaming also has the per-turn limits above. | Input | Limit | Where it goes in the request | | - | - | - | | Audio length | 45 seconds | the `audio` file | | Options per question | 32 | the entries in `criteria` | | Combined request text | 1,000 characters by default | `state`, question `instructions`, and `criteria`, including option names | Audio files are also limited to 16 MB. The API and playground use the account's budget for uploads and streaming. Each stream keeps the limit loaded at session start. Account-specific overrides may raise the limit or exempt an account from the character cap; other transport and model limits still apply. Exactly 1,000 is allowed under the default policy. In the playground, only the prompt, option names, and option descriptions you enter count. An empty form starts at zero, and the full budget is available for your input. The fixed question, generated fallback option, and `context` wrapper do not consume the budget. Blank descriptions are sent as `null`; the model supplies the option name as its default description afterwards. The API recognizes this fixed playground template and excludes only its known generated fields. Custom API requests count Unicode code points in content keys and values, including spaces and line breaks. Arrays count all elements; numbers and booleans count as JSON text; `null` counts as zero. JSON punctuation, protocol fields, model names, and question IDs do not count. For example, outside the playground template, `{"context":"Hi"}` counts as 9. Custom instructions, custom fallback text, additional fields, and explicitly supplied descriptions still count. Oversized text returns `422 request_text_too_long` before queuing, with the actual count and limit. Streaming uses the same code: an oversized start closes with 1008; an oversized update preserves the previous configuration. The playground blocks submission without truncating text. ### Working within the limits * **Context:** keep `state` to the facts the decision needs. Move long background material out of the request. * **Audio:** if a recording is longer than 45 seconds, send the part that holds the decision, or split it into shorter clips and make one decision per clip. * **Options:** if you have more than 32 choices, group them into broader options, or ask two questions in turn, such as a category first and then a specific action. * **Option descriptions:** write each one as a short, clear sentence. For example, "The speaker wants a refund." works better than a paragraph. A request that goes over a model input limit is rejected, so no decision is made. Shorten the input and send it again. See [Errors](https://docs.tazolabs.com/guides/errors.md) for how errors are reported. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.