sipgate-ai STT

Speech-to-text API. OpenAI- and ElevenLabs-compatible interfaces on the same key — point whichever SDK you already use at this host.

👉 Interactive playground — try batch & realtime transcription in the browser, no setup.

Endpoints

Authentication

One API key works for both protocols and all endpoints (except /healthz). Send via whichever header your client library already speaks:

Authorization: Bearer <key>       # OpenAI SDKs
xi-api-key: <key>                 # ElevenLabs SDKs

WebSocket clients that can't set custom headers (browsers) also accept the key via the Sec-WebSocket-Protocol subprotocol entry (bearer.<key>) or the ?api_key= / ?token= query parameter.

Models

Pass the model identifier in the model (OpenAI) or model_id (ElevenLabs) field. Authenticated clients can list the available identifiers via /v1/models. Provider-default names from the OpenAI and ElevenLabs SDKs are accepted without modification.

Which one to pick

Three engines run side by side. They differ in ways that change how you integrate, not just in quality — pick on this table, then compare transcription quality yourself in the playground:

Read the partials column before you design a live UI. Only Nemotron streams real incremental partials — it keeps its encoder state across chunks, so a partial costs almost nothing and arrives within ~100 ms. The two vLLM-served engines emulate streaming by re-decoding the whole buffer on a timer, roughly once a second: you do get partial_transcript / ….delta frames, but expect ~1 s granularity, and expect the gap to widen on a long utterance that never commits (the interval scales with the buffer, because the decode cost does too). A partial can also be revised, not just extended — a re-decode may reword what it said before. For word-by-word live UX use Nemotron.

Unknown model names do not fail — they fall back to the default engine. That is what makes whisper-1 and scribe_v2 work unmodified, and it also means a typo silently gets you the default instead of the engine you meant.

Realtime streaming (WebSocket)

Two bidirectional WebSocket surfaces — the client streams PCM audio up while the server streams transcripts back. These are not in the Swagger/OpenAPI spec: OpenAPI cannot describe WebSocket endpoints. Both pick a backend from the requested model the same way the batch endpoints do, and authenticate with the same key (see above).

WS /v1/realtime — OpenAI Realtime style

Client → server (JSON text frames):

• input_audio_buffer.append — {"audio": "<base64 PCM16LE>"}
• input_audio_buffer.commit (or response.create) — finalise the current utterance
• session.update — optional language hint mid-session; also carries per-session custom vocabulary via session.input_audio_transcription.prompt (see Custom vocabulary)

Server → client (JSON):

• session.created
• conversation.item.input_audio_transcription.delta — {"delta": "…"} (incremental)
• input_audio_buffer.committed then conversation.item.input_audio_transcription.completed — {"transcript": "…"}
• error

WS /v1/speech-to-text/realtime — ElevenLabs Realtime style

Connection config is passed as query parameters:

• model_id — backend selector (optional)
• encoding / audio_format — must be pcm_<rate> (default pcm_16000)
• sample_rate — default 16000 (vLLM backends require 16000)
• commit_strategy — manual (default) or vad (server endpoints on silence)
• language_code — optional hint
• include_timestamps — true/false. Word times are session-absolute (they keep running across commits). Nemotron aligns them on the model; the vLLM backends (Qwen3-ASR, Parakeet) approximate them — session_started.config.timestamps_source says which you got (model / estimated).
• timestamps_offset_secs — added to every word time, e.g. to place one leg of a call in the recording's timebase. Any finite value, |value| ≤ 86400.
• VAD tuning (when commit_strategy=vad): vad_threshold, min_speech_duration_ms, vad_silence_threshold_secs
• keyterms — per-session custom vocabulary, repeatable (&keyterms=Meyer&keyterms=Königsallee), CSV or JSON array (see Custom vocabulary)

Client → server (JSON): {"audio_base_64": "<base64 PCM>"} to stream audio, {"commit": true} to finalise (when manual).
Server → client (JSON, discriminated by message_type): session_started, partial_transcript {"text": "…"}, committed_transcript (or committed_transcript_with_timestamps) {"text": "…"}, error.

Custom vocabulary

Product names, street names, proper nouns. Works on every engine, batch and realtime, through the field your SDK already has:

curl -X POST https://stt.sipgate.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $KEY" \
  -F file=@sample.wav -F model=parakeet \
  -F prompt="Meyer, Königsallee, ChargeBee"

It corrects the transcript, it does not steer the decoder. The model transcribes first, then near-misses are rewritten toward your terms (edit distance plus German phonetics, so Meier → Meyer and Königs alleee → Königsallee). Consequences worth designing around:

• A word the model rendered nowhere near your term stays as it is. Custom vocabulary is a repair, not an instruction.
• Keep the list short and specific. Every term costs CPU on every transcript: ~100 terms adds roughly 0.2 s, 1000 terms several seconds. Send the handful that matters for this call, not a dictionary. Prefer Königsallee over Allee — short generic terms capture ordinary words that merely sound similar.
• Realtime terms apply to finals only, never to partials.
• Limits mirror ElevenLabs (batch ≤1000 terms / ≤50 chars, realtime ≤50 / ≤20 chars, ≤5 words per term). Over-limit terms are dropped and logged, not rejected — you still get a 200 with fewer terms applied.

Errors and backpressure

Realtime errors arrive as a JSON frame with a stable code. Branch on code, never on message — the text is for humans and proxies may rewrite it.

Compatibility — honoured, ignored, refused

The interfaces are OpenAI- and ElevenLabs-compatible, which means SDKs send fields we have no engine for. Nothing is silently half-done; every field is in one of three states. Fields not listed here are honoured.

Accepted and deliberately ignored

These do not fail and do not do anything. Don't infer behaviour from a 200:

• diarize, num_speakers — no backend diarizes; every word comes back as speaker_0
• tag_audio_events — no audio-event tagging
• additional_formats — only the default JSON shape is produced
• temperature — not forwarded to any backend
• use_multi_channel — audio is always treated as single-channel
• enable_logging — request logs only ever record a key fingerprint, never audio, so there is nothing to switch off
• webhook_metadata — webhooks are unsupported (see below)

Refused with 501

• webhook=true — no webhook delivery; poll the response instead
• cloud_storage_url — upload the audio in the request

Partially honoured

• timestamps_granularity — none vs. anything else is honoured; character granularity is accepted but you get word timestamps
• Word timestamps are ElevenLabs-surface only. /v1/audio/transcriptions and WS /v1/realtime return no words array (neither does the real OpenAI API in this form). Needing timestamps means using the ElevenLabs endpoints — the key and the engines are the same.

Quick examples

OpenAI-style batch:

curl -X POST https://stt.sipgate.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $KEY" \
  -F file=@sample.wav \
  -F language=de \
  -F response_format=verbose_json

ElevenLabs-style batch with raw PCM (skips server-side ffmpeg, lower latency):

ffmpeg -i sample.wav -f s16le -ac 1 -ar 16000 sample.pcm
curl -X POST https://stt.sipgate.ai/v1/speech-to-text \
  -H "xi-api-key: $KEY" \
  -F file=@sample.pcm \
  -F file_format=pcm_s16le_16 \
  -F language_code=deu

WebSocket streaming (ElevenLabs flavour, with websocat):

websocat -t "wss://stt.sipgate.ai/v1/speech-to-text/realtime?\
model_id=nemotron&encoding=pcm_16000&sample_rate=16000&\
commit_strategy=MANUAL&language_code=deu&\
include_timestamps=true&keyterms=Königsallee&token=$KEY"

(model_id=nemotron because this example asks for live partials and exact word times — see Which one to pick.)

API documentation

• Interactive Swagger UI — /docs
• ReDoc — /redoc
• Raw OpenAPI spec — /openapi.json