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 /telephony/{provider}/answer alpha

Point your Twilio, Plivo or Exotel number at this URL. It answers with whatever XML that provider expects, telling them to open a media websocket back to us. You do not write the XML and you do not choose the agent here — the agent is decided by which number was dialled, which you set with POST /v1/phone-numbers.

Parameters

Returns

XML in the provider's own dialect (TwiML for Twilio, Plivo XML for Plivo, an Exotel applet response), containing the wss:// URL for the media stream.

Example

# You do not call this — the carrier does. Set it as the voice webhook on your number:
#   https://api.latency.cam/telephony/twilio/answer
# Then map the number to an agent:
curl -X POST https://api.latency.cam/v1/phone-numbers \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"number": "+14155550100", "agent_id": "ag_...", "provider": "twilio"}'

# Verify what the carrier will receive:
curl "https://api.latency.cam/telephony/twilio/answer?To=%2B14155550100"

WEBSOCKET /telephony/{provider} alpha

Where the carrier sends the caller audio. Same engine as /ws/stream — turn taking, transcription, the LLM, fillers, synthesis and barge-in — wrapped in each provider's framing, which differs in base64 encoding, keepalive and how a stream identifier is echoed back.

Parameters

Returns

Provider-framed audio, plus clear/checkpoint control messages when the bot is interrupted.

Example

# Opened by the carrier, not by you. To exercise the same engine directly, use /ws/stream.

POST /v1/audio/speech alpha

Synthesise speech in 19 languages. This endpoint reaches every voice we have, including the nine announcement-only languages an agent is not offered. 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/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/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"

POST /v1/voices alpha

Upload any audio or video file and get a voice the agent can speak in. The preset voices come from about fifty trained speakers and sound mechanical on a phone line; a cloned voice moves that ceiling to a recording you control. Send an iPhone memo, a WhatsApp forward, even a video — we take the clearest few seconds of speech out of it, transcribe it ourselves, and keep about nine seconds at 24kHz. You type no transcript, which matters because the synthesiser needs the audio AND its words, and a wrong transcript silently leaks part of your recording into every reply. The voice speaks every language we support, not only the one it was recorded in.

Parameters

Returns

{ id, name, language, transcript, seconds, voice, prepared: { your_file_seconds, used_seconds, used_from_seconds, level_dbfs } }

Errors

Example

curl -X POST https://api.latency.cam/v1/voices \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -F file=@my-voice.m4a -F name="Priya" -F consent_confirmed=true

GET /v1/voices alpha

The voices this account has cloned. Separate from the preset voices in GET /v1/models, which are still available.

Returns

{ voices: [{ id, name, language, transcript, seconds, voice }], count, available }

Example

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

POST /v1/voices/{voice_id}/preview alpha

Returns a WAV of the voice speaking one line. Squashed through 8kHz mu-law by default, because that is what your callers hear — we measured our own audio codec costing more than an entire G.711 line, so auditioning at studio quality hides the only thing that matters. Pass a language to hear the same voice in another one.

Parameters

Returns

audio/wav

Example

curl -X POST https://api.latency.cam/v1/voices/vc_abc123/preview \
  -H "Authorization: Bearer $LATENCY_API_KEY" -H 'Content-Type: application/json' \
  -d '{"language":"ta"}' --output preview.wav

DELETE /v1/voices/{voice_id} alpha

Removes the recording for good, which is what somebody withdrawing consent is asking for. The voice record itself is kept so finished calls that name it still read correctly rather than pointing at nothing.

Returns

{ deleted, recording_removed }

Example

curl -X DELETE https://api.latency.cam/v1/voices/vc_abc123 -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/fillers/pick/{language} alpha

Returns the audio bytes of a single cached filler in the language you ask for, chosen at random from that category so the agent does not repeat itself. This is the endpoint the live call uses.

Parameters

Returns

Raw audio bytes in the requested format.

Example

curl "https://api.latency.cam/v1/fillers/pick/hi?category=ack&format=mulaw_8000" \
  -H "Authorization: Bearer $LATENCY_API_KEY" --output filler.raw

GET /v1/fillers/{filler_id} alpha

Fetch one known filler rather than a random pick. Useful when you have chosen the wording you want and need it to be the same every time, for example an opening line.

Parameters

Returns

Raw audio bytes.

Example

curl https://api.latency.cam/v1/fillers/hi_ack_01 \
  -H "Authorization: Bearer $LATENCY_API_KEY" --output filler.raw

POST /v1/fillers/generate alpha

Synthesise the filler set and write it to disk. Run once after adding a language or changing the default voice. Everything else in the product reads the cache this produces.

Parameters

Returns

{ generated[], skipped[], seconds }

Example

curl -X POST "https://api.latency.cam/v1/fillers/generate?language=hi&force=true" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/translate alpha

our translation engine 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/chat/completions alpha

Point any OpenAI SDK at https://api.latency.cam/v1 and it works. Backed by the reply model provider.

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": "fast",
    "max_tokens": 60,
    "messages": [
      {"role": "system", "content": "Reply in Hindi, under 12 words."},
      {"role": "user", "content": "Mera order kab aayega?"}
    ]
  }'

POST /v1/agents alpha

An agent is a saved call configuration. Every setting the live call accepts is a setting an agent can carry, read from the same object, so there is no mapping layer between the two to drift apart.

Parameters

Returns

{ id, name, version, published_version, config, created_at }

Errors

Example

curl -X POST https://api.latency.cam/v1/agents \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Delivery helpdesk",
    "config": {
      "language": "hi",
      "allowed_languages": ["hi", "ta", "en"],
      "system_prompt": "You are a delivery helpdesk for {{company}}. Reply in under 15 words.",
      "variables": {"company": "Neureek"},
      "goal": "Successful when the caller is told when their order arrives.",
      "lock_voice": true
    }
  }'

GET /v1/agents alpha

Every agent on your account, with its current and published version numbers.

Parameters

Returns

{ agents[], count }

Example

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

GET /v1/agents/{agent_id} alpha

The agent with its full configuration. Pass a version to read an older one.

Parameters

Returns

{ id, name, version, published_version, config, archived, created_at, updated_at }

Errors

Example

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

# an older version
curl "https://api.latency.cam/v1/agents/ag_7f3a2b?version=2" -H "Authorization: Bearer $LATENCY_API_KEY"

PATCH /v1/agents/{agent_id} alpha

Appends a version. Nothing is ever overwritten, so rollback is publishing an older version rather than restoring a backup, and the record of what the agent used to say survives. A version is a few kilobytes of JSON, so this costs almost nothing.

Parameters

Returns

{ id, version, published_version, config }

Errors

Example

curl -X PATCH https://api.latency.cam/v1/agents/ag_7f3a2b \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"config": {"language": "hi", "system_prompt": "Reply in under 10 words."},
       "note": "shorter replies"}'

GET /v1/agents/{agent_id}/versions alpha

Every version, newest first, with its note and whether it is the published one.

Parameters

Returns

{ versions[{version, note, published, created_at}], count, published_version }

Example

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

POST /v1/agents/{agent_id}/publish alpha

Point the agent at a version. Rolling back a bad prompt is publishing the previous version, which takes effect on the next call and needs no deploy.

Parameters

Returns

{ id, published_version }

Errors

Example

curl -X POST https://api.latency.cam/v1/agents/ag_7f3a2b/publish \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" -d '{"version": 3}'

POST /v1/agents/{agent_id}/archive alpha

Archiving hides the agent and stops it taking calls, but keeps it and its history. There is no hard delete for agents, because a deleted agent takes its call history's meaning with it.

Parameters

Returns

{ id, archived }

Example

curl -X POST "https://api.latency.cam/v1/agents/ag_7f3a2b/archive" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

# undo
curl -X POST "https://api.latency.cam/v1/agents/ag_7f3a2b/archive?restore=true" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/config-schema alpha

All 51 call settings, read out of the engine's own configuration object rather than a hand-written copy — names, types, defaults, groups and a note each.

Returns

{ settings[{name, type, default, group, note, enum?}], count, groups[] }

Example

curl https://api.latency.cam/v1/config-schema -H "Authorization: Bearer $LATENCY_API_KEY" | jq '.settings[] | {name, type, default}'

POST /v1/agents/draft alpha

Describe a business in plain language and get back a config: a system prompt written for a phone call, the languages, what counts as success, and what to read off the transcript afterwards. Nothing is created — the response is a config you POST to /v1/agents if you like it.

Parameters

Returns

{ config, ignored[], suggested_name, model, note, draftable_fields[] }

Errors

Example

curl -X POST https://api.latency.cam/v1/agents/draft \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "brief": "We are a courier in Pune. Ring customers whose parcel is out for delivery and check the address is right.",
    "language": "hi"
  }'

POST /v1/agents/{agent_id}/knowledge alpha

Give an agent something to quote from — a price list, a returns policy, a menu. The file is split into chunks, embedded, and stored against this agent only.

Parameters

Returns

{ doc_id, filename, chunks, characters }

Errors

Example

curl -X POST https://api.latency.cam/v1/agents/ag_7f3a2b/knowledge \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -F file=@returns-policy.pdf

GET /v1/agents/{agent_id}/knowledge alpha

What this agent can quote from, with chunk counts.

Parameters

Returns

{ documents[{doc_id, filename, chunks, characters, created_at}], count }

Example

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

DELETE /v1/agents/{agent_id}/knowledge/{doc_id} alpha

Deletes the document and its chunks and embeddings. Takes effect on the next call.

Parameters

Returns

{ deleted, chunks_removed }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/agents/ag_7f3a2b/knowledge/doc_91c4 \
  -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/agents/{agent_id}/knowledge/search alpha

Run the exact retrieval the live call runs, and see what comes back. This is how you find out whether a wrong answer on a call was retrieval or the prompt.

Parameters

Returns

{ results[{text, score, filename, doc_id}], count }

Example

curl -X POST https://api.latency.cam/v1/agents/ag_7f3a2b/knowledge/search \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "refund kitne din mein milega?", "top_k": 3}'

GET /v1/calls alpha

Every call, newest first, with duration, language, turn count, goal verdict and extracted variables.

Parameters

Returns

{ calls[], count }

Example

curl "https://api.latency.cam/v1/calls?limit=20" -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/calls/{call_id} alpha

The whole call: every turn with its transcript and reply, which tools ran and what they returned, language switches, the goal verdict with its reasoning, and per-turn latency.

Parameters

Returns

{ id, agent_id, agent_version, from, to, duration_s, languages[], turns[], variables{}, goal{}, recording_url?, timings{} }

Errors

Example

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

GET /v1/calls/{call_id}/recording alpha

The recording, if the agent was configured to keep one. By default it redirects to a short-lived signed URL rather than proxying the bytes, so the audio comes from storage near the listener instead of through the API host.

Parameters

Returns

307 to a signed URL, or { url, expires_in } when redirect=false.

Errors

Example

# from a server: get the URL, do not follow the redirect
curl "https://api.latency.cam/v1/calls/call_8823ad/recording?redirect=false" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

# or just download it
curl -L https://api.latency.cam/v1/calls/call_8823ad/recording \
  -H "Authorization: Bearer $LATENCY_API_KEY" --output call.wav

POST /v1/phone-numbers alpha

Say which agent answers when this number is dialled. This is the mapping the carrier webhook reads, and it is the whole of inbound configuration.

Parameters

Returns

{ number, agent_id, provider, label }

Errors

Example

curl -X POST https://api.latency.cam/v1/phone-numbers \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"number": "+14155550100", "agent_id": "ag_7f3a2b",
       "provider": "twilio", "label": "Main support line"}'

GET /v1/phone-numbers alpha

Every number and the agent it rings.

Returns

{ numbers[{number, agent_id, agent_name, provider, label}], count }

Example

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

DELETE /v1/phone-numbers/{number} alpha

Stop an agent answering this number. Calls to it then hear a spoken "not configured" message rather than dead air, which is diagnosable.

Parameters

Returns

{ deleted }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/phone-numbers/%2B14155550100 \
  -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/provider-accounts/fields alpha

The credential fields for Twilio, Plivo and Exotel, with which ones are secret. The dashboard builds its connect form from this, so the form cannot fall out of step with what the dialler actually reads.

Returns

{ providers{twilio[], plivo[], exotel[]}, encryption_available, note }

Example

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

POST /v1/provider-accounts alpha

Store the credentials we dial out with, and the number outbound calls come from. Secret fields are encrypted at rest and cannot be read back.

Parameters

Returns

{ id, provider, from_number, label, fingerprints{} }

Errors

Example

curl -X POST https://api.latency.cam/v1/provider-accounts \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "twilio",
    "from_number": "+14155550100",
    "credentials": {"account_sid": "ACxxxx", "auth_token": "xxxx"},
    "label": "Twilio main"
  }'

GET /v1/provider-accounts alpha

Your carrier accounts, with credential fingerprints instead of credentials.

Returns

{ accounts[{id, provider, from_number, label, fingerprints{}, created_at}], count }

Example

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

DELETE /v1/provider-accounts/{account_id} alpha

Removes the account and its stored credentials.

Parameters

Returns

{ deleted }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/provider-accounts/pa_3d81 \
  -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/contact-lists alpha

Who to call, and what the agent should know about each of them. Accepts either JSON contacts or pasted CSV text — a customer pastes a CSV, an integration posts JSON, and forcing either to use the other's shape is friction for no gain.

Parameters

Returns

{ id, name, contacts, skipped[], variables_found[] }

Errors

Example

curl -X POST https://api.latency.cam/v1/contact-lists \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "October EMI reminders",
    "csv": "phone,name,amount,due_date\n+919876543210,Asim,15250,4 October\n+919876543211,Priya,8400,7 October"
  }'

GET /v1/contact-lists alpha

Your lists with their sizes.

Returns

{ lists[{id, name, contacts, created_at}], count }

Example

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

GET /v1/contact-lists/{list_id} alpha

The contacts, with the variables attached to each.

Parameters

Returns

{ id, name, contacts[{number, variables{}}], count }

Errors

Example

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

DELETE /v1/contact-lists/{list_id} alpha

Removes the list and its contacts. Calls already made keep their own record.

Parameters

Returns

{ deleted }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/contact-lists/cl_44a2 -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/dnc alpha

Numbers we will never dial, whatever a campaign says. Checked at dial time rather than at list upload, so adding a number here stops a campaign that is already running.

Parameters

Returns

{ added, numbers[] }

Example

curl -X POST https://api.latency.cam/v1/dnc \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"numbers": ["+919876543210"], "reason": "asked not to be called"}'

GET /v1/dnc alpha

Every suppressed number with its reason and when it was added.

Returns

{ numbers[{number, reason, created_at}], count }

Example

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

DELETE /v1/dnc/{number} alpha

Take a number off do-not-call. Do this only with a record of consent.

Parameters

Returns

{ deleted }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/dnc/%2B919876543210 -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/campaigns alpha

Take a contact list, an agent and a carrier account, and call everyone — at a set concurrency, inside a calling window, retrying no-answers.

Parameters

Returns

{ id, name, status, contacts, concurrency, window, created_at }

Errors

Example

curl -X POST https://api.latency.cam/v1/campaigns \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "October EMI reminders",
    "agent_id": "ag_7f3a2b",
    "list_id": "cl_44a2",
    "account_id": "pa_3d81",
    "concurrency": 3,
    "window_start": "10:00",
    "window_end": "19:00",
    "timezone": "Asia/Kolkata"
  }'

# check it, then start it
curl -X POST https://api.latency.cam/v1/campaigns/cm_9911/start -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/campaigns alpha

Every campaign with its status and progress.

Returns

{ campaigns[{id, name, status, contacts, attempted, completed, goal_met}], count }

Example

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

GET /v1/campaigns/{campaign_id} alpha

Status, settings, progress counts and why it is not dialling right now if it is not — outside the window, paused, or waiting on retries.

Parameters

Returns

{ id, name, status, agent_id, agent_version, contacts, attempted, in_flight, completed, goal_met, window{}, holding_because? }

Errors

Example

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

GET /v1/campaigns/{campaign_id}/calls alpha

Every attempt, with outcome, attempt number and the call id to read in full.

Parameters

Returns

{ calls[{call_id, number, status, attempt, goal_met, duration_s}], count }

Example

curl "https://api.latency.cam/v1/campaigns/cm_9911/calls?status=no_answer" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/campaigns/{campaign_id}/start alpha

Begin dialling. Also resumes a paused campaign, picking up where it left off rather than starting again — contacts already attempted are not called twice.

Parameters

Returns

{ id, status }

Errors

Example

curl -X POST https://api.latency.cam/v1/campaigns/cm_9911/start -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/campaigns/{campaign_id}/pause alpha

Stop starting new calls. Calls already connected are left to finish — cutting off a live conversation to honour a pause would be worse for the person on the phone than letting it end.

Parameters

Returns

{ id, status, in_flight }

Errors

Example

curl -X POST https://api.latency.cam/v1/campaigns/cm_9911/pause -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/campaigns/{campaign_id}/cancel alpha

Abandon the campaign. Pending contacts are dropped and it cannot be restarted. Live calls finish. Separate from pause because "stop for now" and "never dial these people" are different intentions and collapsing them into one button gets one of them wrong.

Parameters

Returns

{ id, status, dropped }

Errors

Example

curl -X POST https://api.latency.cam/v1/campaigns/cm_9911/cancel -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/calls/outbound alpha

One call, to one person, with one agent — no contact list and no campaign. This is the test dial behind the button in the agent editor, and it is also the endpoint for a call your own application triggers: an order shipped, a payment failed, a ticket escalated.

Parameters

Returns

202 with { status: "dialing", to_number, from_number, provider, provider_call_id, agent_id, agent_version, note }

Errors

Example

curl -X POST https://api.latency.cam/v1/calls/outbound \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to_number": "+919876543210",
    "agent_id": "ag_7f3a2b",
    "account_id": "pa_3d81",
    "variables": {"name": "Asim", "order_id": "A-1029"}
  }'

PUT /v1/provider-accounts/{account_id}/numbers alpha

Give an account several numbers to dial from. Calls are handed out round-robin, which spreads the load evenly and keeps any single number from being scored as a spam source.

Parameters

Returns

The updated account, including from_numbers and rotation_cursor.

Errors

Example

curl -X PUT https://api.latency.cam/v1/provider-accounts/pa_3d81/numbers \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"numbers": ["+918000000001", "+918000000002", "+918000000003"]}'

GET /v1/analytics/summary alpha

Calls, talk time, goal rate, and the measured latency of your own traffic broken into stages. This is where you check our speed claims against your calls rather than taking our word for it.

Parameters

Returns

{ summary{}, daily[], latency{ttfa_ms, turn_ms, stt_ms, llm_ms, tts_ms, totals, sampled}, note }

Example

curl "https://api.latency.cam/v1/analytics/summary?since=2026-09-01" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/analytics/breakdown alpha

Counts, average length and goal rate, grouped by language, how the call ended, agent, or agent version.

Parameters

Returns

{ by, rows[{value, calls, avg_seconds, goal_met, goal_scored, goal_met_rate}], count }

Errors

Example

curl "https://api.latency.cam/v1/analytics/breakdown?by=agent_version" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/analytics/search alpha

Full-text search over transcripts, ranked, with the match shown in context. Indic scripts are searchable, which is not free: the tokeniser keeps combining marks, without which Devanagari and Tamil words are mangled into strings nobody would ever search for.

Parameters

Returns

{ query, hits[{call_id, excerpt, started_at, language, goal_achieved}], count }

Example

curl "https://api.latency.cam/v1/analytics/search?q=refund" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/analytics/reindex alpha

Re-reads every transcript into the search index. Needed after restoring a backup or importing calls, and harmless otherwise.

Returns

{ indexed, seconds }

Example

curl -X POST https://api.latency.cam/v1/analytics/reindex -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/analytics/analyse alpha

Takes a sample of calls that did not meet their goal, reads the transcripts, and returns recurring themes with the call ids behind each one and a suggested fix.

Parameters

Returns

{ themes[{theme, why, fix, call_ids[], count}], sampled, model }

Errors

Example

curl -X POST https://api.latency.cam/v1/analytics/analyse \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "ag_7f3a2b", "sample": 20}'

POST /v1/boards alpha

A board is a question about your calls, saved so you can ask it again tomorrow. The filters object is free-form and stored as given, so the dashboard decides what a board contains without that being a schema change here.

Parameters

Returns

{ id, name, filters, created_at }

Example

curl -X POST https://api.latency.cam/v1/boards \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Tamil calls this week",
       "filters": {"agent_id": "ag_7f3a2b", "widgets": ["language", "ended_by"]}}'

GET /v1/boards alpha

Your boards with their filters.

Returns

{ boards[{id, name, filters, created_at}], count }

Example

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

DELETE /v1/boards/{board_id} alpha

Removes the saved filters. No call data is touched.

Parameters

Returns

{ deleted }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/boards/bd_69da5b -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/webhooks/events alpha

The event list, the signing scheme with a worked verification example, and the retry policy. Read this first — it is the only page you need to integrate webhooks.

Returns

{ events{}, signature{header, timestamp_header, algorithm, why, example}, retries{backoff_seconds[], disabled_after_consecutive_failures, timeout_seconds} }

Example

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

POST /v1/webhooks alpha

Tell us where to POST when something happens. The signing secret is returned once.

Parameters

Returns

{ id, url, events[], secret, active, created_at } — the secret appears in this response only.

Errors

Example

curl -X POST https://api.latency.cam/v1/webhooks \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/hooks/latency",
       "events": ["call.completed", "campaign.finished"],
       "description": "into the CRM"}'

GET /v1/webhooks alpha

Every subscription, whether it is active, and its recent failure count.

Returns

{ webhooks[{id, url, events[], active, description, consecutive_failures, created_at}], count }

Example

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

DELETE /v1/webhooks/{hook_id} alpha

Stop delivering to this URL and forget its secret.

Parameters

Returns

{ deleted }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/webhooks/wh_2f81 -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/webhooks/{hook_id}/enable alpha

Re-enable a webhook that was disabled after repeated failures, once the receiving end is fixed.

Parameters

Returns

{ id, active }

Errors

Example

curl -X POST https://api.latency.cam/v1/webhooks/wh_2f81/enable -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/webhooks/deliveries alpha

The delivery log: which event, which webhook, what status came back, how many attempts and the error if there was one.

Parameters

Returns

{ deliveries[{id, webhook_id, event, status, attempts, error, next_try_at, created_at}], count }

Example

curl "https://api.latency.cam/v1/webhooks/deliveries?limit=20" \
  -H "Authorization: Bearer $LATENCY_API_KEY"

POST /v1/webhooks/{hook_id}/test alpha

Fires a sample event at your URL through the real queue and the real signing path, so a signature you can verify here is a signature you can verify in production.

Parameters

Returns

202. The result appears in GET /v1/webhooks/deliveries.

Errors

Example

curl -X POST https://api.latency.cam/v1/webhooks/wh_2f81/test -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/me alpha

The account behind the credential you just used, and what it can see. The first thing to call when two people share a deployment and you need to know whose data you are looking at.

Returns

{ org{id, name, created_at, members[{user_id, email, role, created_at}]}, usage{counts{agents, calls, documents, api_keys, phone_numbers, provider_accounts, contact_lists, campaigns, webhooks, boards}, call_seconds}, authenticated_as{kind, label, user_id, email, is_operator} }

Example

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

GET /v1/auth/config alpha

What a sign-in page needs before it has any credential: whether accounts are enabled, and the public details to authenticate against. Open for that reason.

Returns

{ sign_in{enabled, url, publishable_key, algorithms[]}, api_keys, note }

Example

curl https://api.latency.cam/v1/auth/config

POST /v1/api-keys alpha

Create an API key for this account. The full key is returned once and only a hash is stored, so there is no endpoint that can read it back.

Parameters

Returns

{ id, name, prefix, key, created_at } — `key` appears in this response only.

Example

curl -X POST https://api.latency.cam/v1/api-keys \
  -H "Authorization: Bearer $LATENCY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "CRM integration"}'

GET /v1/api-keys alpha

Every key with its prefix, when it was last used and how often — never the key itself.

Parameters

Returns

{ keys[{id, name, prefix, created_at, last_used_at, uses, revoked_at}], count }

Example

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

DELETE /v1/api-keys/{key_id} alpha

Stops working immediately, on HTTP and on the websocket. The row survives so the audit trail does.

Parameters

Returns

{ id, revoked_at }

Errors

Example

curl -X DELETE https://api.latency.cam/v1/api-keys/ak_51c2 -H "Authorization: Bearer $LATENCY_API_KEY"

GET /v1/models alpha

The full catalog: transcription with measured error rates, the 20 preset voices an agent can be given, the valid emotion tags, and the language counts. Voices for the nine speak-only languages are not listed here because an agent cannot use them — reach those through /v1/audio/speech.

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 answering, and whether authentication is enforced. The one endpoint that needs no key, so a monitor can poll it. Send a key as well and it adds readiness, which is the part that tells you whether a call will actually connect.

Returns

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

Example

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