Endpoints

WEBSOCKET /ws/stream alpha

One websocket per phone call. Push the caller audio in 20ms frames and play whatever comes back. Speech detection, turn taking, transcription, the LLM, filler injection, synthesis and barge-in all happen server side, so a working voice agent is a websocket and an audio pipe — not an orchestration layer you have to build. This is the endpoint to use for calls; the REST endpoints are the building blocks under it.

Parameters

Returns

A mix of JSON text frames (events) and binary frames (bot audio in the format you configured). Binary frames are raw audio with no header — write them straight to the call.

Errors

Example

# Websockets are not curl-able. Minimal Python client:
import asyncio, json, websockets

async def call():
    url = "wss://api.latency.cam/ws/stream?api_key=" + KEY
    async with websockets.connect(url, max_size=None) as ws:
        await ws.send(json.dumps({
            "type": "configure",
            "language": "hi", "script": "roman",
            "audio_format": "mulaw_8000",
            "system_prompt": "You are a delivery helpdesk. Reply in Hindi, under 12 words.",
        }))
        async def send_caller_audio():
            # 160-byte frames of 8kHz mulaw, one every 20ms
            for frame in caller_frames():
                await ws.send(frame)
                await asyncio.sleep(0.02)
        asyncio.create_task(send_caller_audio())
        async for msg in ws:
            if isinstance(msg, bytes):
                play_to_caller(msg)       # raw audio, no header
            else:
                print(json.loads(msg))    # events

asyncio.run(call())

POST /v1/audio/speech alpha

Synthesise speech in 19 languages across 38 voices. Set stream=true for live calls: audio arrives in chunks as it is generated, so playback starts long before synthesis finishes.

Parameters

Returns

Raw audio in the requested format. Response headers carry X-Model-Used, X-Generate-Ms, X-Quality-Check and X-Cache.

Errors

Example

curl -X POST https://api.latency.cam/v1/audio/speech \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "Aapka EMI 15250 rupay ka hai, due date 4 tarikh hai.",
    "language": "hi",
    "script": "roman",
    "format": "mulaw_8000",
    "stream": true
  }' --output reply.raw

POST /v1/audio/transcriptions alpha

Transcribe caller audio. Accepts wav, mp3, flac, ogg and raw mulaw or PCM. Optionally detects the language first.

Parameters

Returns

{ text, model_used, inference_ms, engine_ms, language, requested_language, detected_language, script, candidate_languages, detection_source, language_probability, duration_s }

Errors

Example

curl -X POST https://api.latency.cam/v1/audio/transcriptions \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -F file=@call.wav \
  -F language=te

POST /v1/translate alpha

IndicTrans2 distilled 200M, running on CPU so it never competes with the GPU that serves your calls. English to any Indian language and back, plus Indic to Indic.

Parameters

Returns

{ translations[], source_language, target_language, source_tag, target_tag, pivoted_through_english, model, latency_ms, queued_ms, inference_ms, backend }

Errors

Example

curl -X POST https://api.latency.cam/v1/translate \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Your order will arrive tomorrow between 10 am and 12 pm.",
    "source_language": "en",
    "target_language": "ta"
  }'

GET /v1/translate/languages alpha

The 23 codes accepted by /v1/translate, and which directions are direct versus pivoted.

Returns

{ languages[], count, directions[], backends{} }

Example

curl https://api.latency.cam/v1/translate/languages -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/lid alpha

Spoken language identification across 42 Indian languages, using Vaani-LID. Use it when you do not know what the caller will speak.

Parameters

Returns

{ candidates: [{ language, confidence }], duration_s, warning? }

Errors

Example

curl -X POST https://api.latency.cam/v1/lid \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -F file=@caller.wav \
  -F 'restrict_to=["ta","te","kn","ml"]'

POST /v1/chat/completions alpha

Point any OpenAI SDK at https://api.latency.cam/v1 and it works. Backed by Amazon Bedrock.

Parameters

Returns

An OpenAI chat.completion object, plus latency_ms.

Errors

Example

curl -X POST https://api.latency.cam/v1/chat/completions \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nova-lite",
    "max_tokens": 60,
    "messages": [
      {"role": "system", "content": "Reply in Hindi, under 12 words."},
      {"role": "user", "content": "Mera order kab aayega?"}
    ]
  }'

POST /v1/normalize alpha

Rewrites digits, currency and dates into words with Indian grouping, so TTS says them correctly. Called automatically by /v1/audio/speech; exposed separately so you can inspect or override it.

Parameters

Returns

{ text, coverage, replacements[] }

Example

curl -X POST https://api.latency.cam/v1/normalize \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Rs 15,250 due on 4/11", "language": "hi", "script": "roman"}'

GET /v1/fillers alpha

Short acknowledgements rendered ahead of time and cached on disk. Play one the instant the caller stops speaking, then stream the real reply behind it. This does not reduce measured latency at all — it removes the silence the caller would otherwise sit through, which is the thing that actually makes a bot feel broken.

Returns

{ fillers[], categories, languages, _how_to_use }

Example

curl https://api.latency.cam/v1/fillers -H "Authorization: Bearer $LATENCY_API_KEY"

# pick one and play it the moment the caller stops talking
curl "https://api.latency.cam/v1/fillers/pick/hi?category=ack" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/models alpha

The full catalog: STT models with measured error rates, the TTS model with all 38 voices and valid emotion tags, and the LID model.

Returns

{ stt[], tts[], lid[], _read_this_first }

Example

curl https://api.latency.cam/v1/models -H "Authorization: Bearer $LATENCY_API_KEY"

GET /health alpha

Whether the service is up, which models are loaded, how much VRAM is free, and whether auth is enabled. The one endpoint that does not need a key, so you can poll it while the box boots.

Returns

{ ok, build, uptime_seconds, auth, gpu{}, models{} }

Example

curl https://api.latency.cam/health

POST /v1/clone planned

Returns 501. This is the one place where "no restrictions" does not extend to the open internet, and it is also genuinely not built yet. Cloning needs svara-tts-voiceclone-beta, a 6.6GB model, and the GPU currently has about 6.8GB free because vLLM holds the rest to keep call latency low. Fitting it means either a second GPU or replacing the default TTS model with the beta one.

Parameters

Returns

501 with an explanation. 403 first if consent_confirmed is not true.

Errors

Example

# Returns 501. Preset voices work today:
curl https://api.latency.cam/v1/models -H "Authorization: Bearer $LATENCY_API_KEY" | jq '.tts[0].voices'