Skip to main content
WSS
Low-latency multilingual speech-to-text over WebSocket. The spoken language is identified automatically, so the client declares no language and uses no per-language endpoint. Interim partial transcripts stream while audio arrives, and a final utterance is emitted for each segment of speech. This endpoint produces no emotion, accent, or PII/PHI data. Use STT Streaming if you need those.

​
Endpoint

​
Authentication

The API key goes in the query string at connection time, not in a header. See Authentication and rate limits.

​
Supported audio formats

Container formats — sample_rate and num_channels are ignored if supplied: mp3, wav, flac, m4a, mp4, ogg, opus, webm, aac, aiff, wma, amr, and au, plus 66 others
3g2, 3ga, 3gp, 3gpp, 8svx, aa3, aac, ac3, act, adts, aif, aifc, aiff, amb, amr, asf, at3, au, avr, awb, bwf, c2, caf, dss, dts, dtshd, eac3, ec3, f4a, f4b, flac, gsm, iff, m2a, m2ts, m4a, m4b, m4r, m4v, mka, mkv, mlp, mp+, mp1, mp2, mp3, mp4, mpa, mpc, mpga, mpp, mts, oga, ogg, ogx, oma, omg, opus, paf, pvf, qcp, ra, rf64, rm, rmvb, snd, svx, thd, ts, tta, voc, vqf, w64, wav, wave, weba, webm, wma, wmv
The MP4-family values (mp4, m4a, m4b, m4r, m4v, 3gp, 3gpp, 3ga, 3g2, f4a, f4b) must be sent in a streamable layout; otherwise the connection ends with an audio-processing error. Raw PCM formats — sample_rate and num_channels are required: s8, s16le, s16be, s24le, s24be, s32le, s32be, u8, u16le, u16be, u24le, u24be, u32le, u32be, f32le, f32be, f64le, f64be, mulaw, alaw, g722, vox g722 and vox are mono-only: num_channels must be 1. Valid sample rates: 8000, 11025, 16000, 22050, 32000, 44100, 48000, 96000 For lowest end-to-end latency, send audio_format=s16le&sample_rate=16000&num_channels=1.

​
Query parameters

endpointing, diarize, time_stamps, and detect_language are independent; every combination is valid.
Worth knowing: diarize=true substantially increases time-to-first-text. Speaker decisions are made over a multi-second window, so the first partial_utterance arrives several seconds later than on a non-diarized connection, and the gap widens under concurrency. Transcript accuracy is unaffected - the cost is latency, not quality. If you are rendering live captions, either size the interface for this or run a second, non-diarized connection for the display text.

​
Language identification

The spoken language is identified automatically across these 25 languages: Bulgarian, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Russian, Slovak, Slovenian, Spanish, Swedish, Ukrainian. Each utterance is transcribed in the language spoken, with auto-capitalization and auto-punctuation already applied. The client declares no language, and recognition quality varies by language.
Worth knowing: this set is smaller and narrower than it sounds. Multilingual Transcription covers 100 languages; these 25 are all European, so Chinese, Japanese, Arabic, Hindi and Korean are not among them. Audio outside the set is still transcribed, but not reliably.

​
Reporting the detected language

With detect_language=true, each final utterance carries language: the ISO 639-1 code of one of the 25 languages above (es, de, en, and so on). Partials never carry it. With detect_language=false, no message carries a language field. language is null when the utterance is too short to identify reliably. That is a deliberate result, not a dropped field or a low-confidence guess.
Worth knowing: expect null often on short utterances. A single word or a back-channel such as “yes” or “okay” commonly returns null, and with diarize=true speaker changes produce many short utterances. A client that needs the conversation’s language should take it from the longer utterances rather than the most recent one.

​
Speaker labels

With diarize=true, each final utterance carries speaker, a zero-based index identifying who produced it. Partials never carry it, and a label is assigned when an utterance is finalized and never revised. The index is stable for one connection and meaningless outside it: the same person on a new connection may receive a different index, so it is not an identity that can be matched across connections. speaker is null when diarization was requested but no speaker could be determined for that utterance. That is distinct from the field being absent, which means diarize=true was not requested.

​
Speaker capacity

Up to four concurrent speakers are labeled per connection. Beyond four, additional speakers are merged into existing labels: their speech is still transcribed, but speaker is wrong for some utterances.
Worth knowing: speakers_capped and speaker_purity are the two signals that a label may be unreliable, and a client acting on speaker identity should check both. The four-speaker ceiling is lower than English Fast Transcription (streaming), which labels ten, so a conversation that diarizes cleanly there can exceed capacity here.

​
Utterances that span a speaker change

Segments are cut at pauses regardless of diarize. An utterance spanning a fast exchange with no pause carries the speaker who produced most of it, and speaker_purity reports what proportion that was. 1.0 is cleanly single-speaker; lower means the label describes only the majority.

​
With endpointing off

diarize=true&endpointing=false produces one final utterance for the whole stream, so a single speaker cannot describe it. Read n_speakers and treat speaker as indicative only.

​
Word timestamps

With time_stamps=true, each final utterance carries words: one entry per word of text, in order, each with word, start_ms, and end_ms. Partials never carry it. Word times are milliseconds from the start of the stream, the same clock as the utterance’s start_ms, not offsets within the utterance. Each word matches the utterance text, punctuation and casing included. Timings are computed alongside the transcript, so requesting them changes neither the text nor the latency. With time_stamps=false, words is absent rather than an empty array.

​
Session limits

A connection can stream for up to six hours. If no audio frame arrives for five minutes, the stream is finalized as though the end-of-stream frame had been sent. Either way the server sends the final utterance for any remaining speech, then done, and closes with 1000. Reaching a limit is not an error. The five-minute limit counts from the last audio frame received, not the last speech, so streaming silence keeps the connection open.

​
Connection flow

  1. Connect with api_key, audio_format, (for raw formats) sample_rate and num_channels, and any of endpointing, diarize, time_stamps, and detect_language.
  2. Stream audio as binary WebSocket frames.
  3. Receive partial_utterance messages while audio arrives.
  4. Send an empty text frame ("") to signal end of audio.
  5. Receive the final utterance(s), then a done message.
  6. The connection closes.
Worth knowing: step 4 must be a text frame containing the empty string. An empty binary frame is treated as an audio chunk and does not end the stream, so the connection hangs until it times out with no final utterance.

​
Server messages

​
partial_utterance

The complete transcript so far for the current scope — the whole connection by default, or the current segment when endpointing=true. Not a delta: replace the displayed text on each message, never append.
Partials never carry speaker fields, even with diarize=true.

​
utterance

The final transcript for one segment. Will not be revised.
With time_stamps=true and detect_language=true:
With diarize=false no speaker field appears in any message. Likewise, words appears only with time_stamps=true and language only with detect_language=true.

​
done

Sent once, immediately after the final utterance. The server closes after it.

​
error

Sent if something goes wrong. The connection closes after it; no further messages follow.
That second message means speaker labelling is not enabled on the instance that served the connection. Retry once — instances can differ while a deployment is rolling — and if it persists, reconnect without diarize. time_stamps=true is not available on this endpoint. means the same for word timestamps.

​
WebSocket close codes

query
type:object
Partial Utterance Result
type:object

In-progress transcript snapshot for the CURRENT speech segment. Sent zero or more times per segment, roughly every 1.5 seconds. The text field contains the current segment's transcript so far - not a delta, and not the whole stream - with auto-capitalization and auto-punctuation already applied. Clients should REPLACE the current segment's previously displayed partial text, not append. Partials never carry speaker labels, even with diarize=true, and never carry word timestamps, even with time_stamps=true.

Final Utterance Result
type:object

The final transcript for one segment of speech, with auto-capitalization and auto-punctuation applied, plus the segment's start time and duration. With diarize=true it also carries the speaker who produced it, with time_stamps=true the start and end time of every word, and with detect_language=true its detected language. Sent once per segment (when the segment ends, and once more for the last segment after end-of-stream), and supersedes the partial_utterance messages for that segment. The full transcript is the concatenation of these texts in order.

Error
type:object

An error occurred during transcription. Sent at most once per connection; the WebSocket closes shortly after. No further messages follow an error.

Transcription Complete
type:object

Transcription completed successfully. Sent exactly once, immediately after the final utterance message. After this message the server closes the WebSocket.

Audio Data Chunk
type:string

Raw audio data chunk for transcription. Sent zero or more times by the client during the stream lifetime. Each chunk's bytes are decoded by the server according to the connection's audio_format query parameter.

End of Audio Stream
type:string

Empty text frame signaling end of audio. Sent exactly once by the client after the last audio chunk. The server responds with a final utterance message followed by a done message, then closes the connection.