Rate Limits

Nineninesix enforces two limits, both per org: a request rate (requests per minute) and a concurrency cap (simultaneous streams). They scale by your tier.

Limits are shared across your whole org. All of your API keys draw on one rate-limit bucket, one concurrency pool, and one tier — extra keys are for rotation and security, not more capacity. Creating five keys does not give you five times the limits.

Tiers

Tier	Requests / min	Concurrent streams	How to reach it
`tier1`	60	5	Default for every new org
`tier2`	600	25	Automatic once your org’s cumulative purchases reach $50
`tier3`	6,000	100	High volume — contact us

These are current limits, not hard caps — we raise them per customer as you scale. Contact us if you need more headroom.

What counts as a request

The requests-per-minute limit counts new requests started per minute:

POST /tts/bytes and POST /tts/sse — one request per HTTP call.
GET /tts/websocket — one request per connection, spent at handshake, not per message. A long-lived socket streaming many turns costs a single request token when it opens; what bounds its ongoing work is the concurrency cap.

How concurrency is measured

This is the important, non-obvious part. A stream counts against your concurrency limit only while it is actively generating audio — not for the socket’s lifetime, and not for the whole call.

A slot is held only while a turn is generating, then freed as soon as the turn finishes.
Idle time between turns (the user talking, silence, thinking) costs nothing.

So “concurrent” counts simultaneous active-speech turns, not simultaneous calls. Because only ~10–30% of a typical conversation is active TTS, one slot comfortably serves many live calls — you only approach the limit when that many turns are generating at the same moment. In practice Tier 1’s 5 concurrent supports far more than 5 live conversations. Hold a socket open per call for free; you only pay concurrency for overlapping speech.

Handling 429 Responses

When you exceed a limit you’ll receive 429 Too Many Requests with a Retry-After header:

{ "error": "rate_limited", "message": "requests/min limit exceeded for your tier" }

Concurrency rejections look like:

{ "error": "concurrent_limit", "message": "concurrent stream limit reached for your tier" }

If a turn exceeds the concurrency limit, only that one context is rejected — the socket and your other contexts keep running. Back off and retry that turn on a fresh context_id; there’s no “push through,” since continuing to stream a rejected context produces no audio. Rejected turns aren’t charged. Separately from your tier limits, overloaded (429) means the synthesis servers are at capacity. Back off and retry; don’t rely on a Retry-After header for it.

import time
from cartesia import Cartesia

client = Cartesia(api_key="sk_996_your_api_key", base_url="https://api.nineninesix.ai")

def generate(transcript: str, attempt: int = 0):
    try:
        return client.tts.bytes(
            model_id="gepard-1.0",
            transcript=transcript,
            voice={"mode": "id", "id": "<voice-id>"},
            output_format={"container": "wav", "encoding": "pcm_s16le", "sample_rate": 22050},
        )
    except Exception:
        if attempt >= 3:
            raise
        time.sleep(2 ** attempt)
        return generate(transcript, attempt + 1)

Credits

Billing is separate from rate limits and is keyed to your org, shared across all its keys. Each character of transcript costs 1 credit; $15 buys 1,000,000 characters and credits never expire. Billing is postpaid: requests start only while your balance is above zero, and once it reaches zero you’ll get a 402 payment_required — top up on the Billing page.

Best Practices

Cache generated audio — don’t regenerate the same text repeatedly
Respect concurrency — pool and reuse streams rather than opening unbounded connections
Back off on 429 — use the Retry-After header when present, and retry rejected turns on a fresh context_id
Monitor your dashboard — watch usage and balance before hitting limits

Getting Started

Guides

Resources

Tiers

What counts as a request

How concurrency is measured

Handling 429 Responses

Credits

Best Practices

​Tiers

​What counts as a request

​How concurrency is measured

​Handling 429 Responses

​Credits

​Best Practices

Tiers

What counts as a request

How concurrency is measured

Handling 429 Responses

Credits

Best Practices