Rate limits

Kova limits concurrency, not request volume. There is no per-minute or per-hour throttle, and no cap on requests per day.

The limit

Tier	Max concurrent in-flight	Per-minute / per-hour	Max chars per request
Standard (`kova_sk_`)	9	no throttle	no limit

Your key may have 9 requests generating at once. The 10th concurrent request is rejected immediately with a 429 — nothing queues server-side.

Measured, not theoretical: firing 20 simultaneous requests on one key consistently yields exactly 9 × 200 and 11 × 429.

An open WebSocket that is actively generating occupies one slot, no matter how many utterances or contexts pass through it. That slot comes from the same pool of 9 as your HTTP requests. With 9 WebSocket connections generating, a concurrent POST /v1/tts on the same key returns 429. The slot frees as soon as the connection stops generating.

This makes WebSocket the efficient choice for voice agents: one long-lived connection handles an entire multi-turn session while holding a single slot, where the same session over HTTP would consume a slot per utterance.

What a 429 looks like

{"error": "Rate limit exceeded", "reason": "concurrency"}

Status 429, Content-Type: application/json, with an x-request-id header.

There is no Retry-After header on 429 responses. Don’t wait for the server to tell you when to retry — it won’t. Pick your own schedule.

Recommended client-side patterns

Bound your own concurrency

Hold a semaphore of 9 or fewer in your application. Backpressure or shed load once it’s full — this is cheaper than discovering the limit through 429s.

Retry with jittered backoff

On 429, retry with exponential backoff plus jitter. Start at 200 ms, cap around 5 s. Jitter matters — synchronized retries re-collide.

Split across keys

Each key gets its own budget of 9. Use one key per service or environment for both isolation and throughput.

Reuse one WebSocket

One connection serves a whole session on a single slot, instead of one slot per utterance.

A worked backoff

import random, time
import httpx

def tts_with_retry(client, body, headers, attempts=6):
    delay = 0.2
    for attempt in range(attempts):
        r = client.post("https://api.kova.ai/v1/tts", json=body, headers=headers)
        if r.status_code != 429:
            return r
        if attempt == attempts - 1:
            r.raise_for_status()
        time.sleep(delay + random.uniform(0, delay))   # full jitter
        delay = min(delay * 2, 5.0)

Server-wide capacity

Beyond the per-key limit, total concurrent inference across all keys is bounded. Under sustained heavy load, requests can queue briefly even when your key is under its own limit. In practice the per-key limit of 9 is the binding constraint for almost every integration.

Asking for higher limits

For sustained high-volume traffic, contact us to discuss provisioned capacity.

Get started

HTTP API

WebSocket API

Voices

Integrations

SDKs

Reference

Rate limits

The limit

What a 429 looks like

Recommended client-side patterns

Bound your own concurrency

Retry with jittered backoff

Split across keys

Reuse one WebSocket

A worked backoff

Server-wide capacity

Asking for higher limits

​The limit

​HTTP and WebSocket share one budget

​What a 429 looks like

​Recommended client-side patterns

Bound your own concurrency

Retry with jittered backoff

Split across keys

Reuse one WebSocket

​A worked backoff

​Server-wide capacity

​Asking for higher limits

The limit

HTTP and WebSocket share one budget

What a 429 looks like

Recommended client-side patterns

A worked backoff

Server-wide capacity

Asking for higher limits