Skip to main content
Detect when a speaker has finished their turn. Streaming transcription is delivered in turns. A turn is one continuous unit of speech belonging to a single speaker. Deciding when a turn has ended, called endpointing, determines how an interactive voice application feels. End turns too early and you cut speakers off mid-thought or split a complex entity like a phone number into multiple parts. End turns too late and your voice agent feels unresponsive.

​
How turn detection works

Universal-3.6 Pro Streaming does not endpoint on silence alone. When a speaker pauses, the model evaluates what has been said so far to judge whether the speaker is finished or just pausing mid-thought. If the turn ends in an entity that may still continue, such as part of a phone number, the turn stays open. This is called entity-aware endpointing. Two silence thresholds control this behavior. Lower values end turns faster. Higher values tolerate longer pauses without fragmenting the turn. Both parameters can be set on the connection and updated mid-stream, and their defaults come from the mode preset you select.
Speaker labels change the defaultsWhen speaker_labels is enabled, the server applies diarization-tuned defaults instead (min_turn_silence: 640, max_turn_silence: 768) so turns break cleanly at speaker changes.

​
Entity-aware endpointing

Phone numbers, account IDs, email addresses, and spelled-out names are the hardest turns to endpoint. Speakers read them out in chunks with real pauses in between, the chunks have no grammatical ending, and the model may already have written a chunk as a finished sentence. An endpointer that ends the turn at the first pause splits the entity across several turns, and your LLM or validation logic receives fragments. Entity-aware endpointing keeps the entity in one turn. When the min_turn_silence check runs and the transcript so far ends like an entity that may still continue, the turn is held open even if it reads as a complete sentence. This covers digits, alphanumeric and spelled-out codes, email addresses and usernames, street addresses, dates, and names. If the speaker continues, the new speech stays in the same turn. If they don’t, the turn ends once the silence reaches max_turn_silence. Turns that end in an ordinary complete sentence still end at min_turn_silence. While a turn is held, you keep receiving partial Turn messages for it, and end_of_turn_confidence rises toward 1.0 as the silence approaches max_turn_silence. Entity-aware endpointing is on by default in every mode on both Universal-3.6 Pro and Universal-3.5 Pro, and needs no parameters. Because a held turn ends at max_turn_silence, the preset you choose also sets how long the session waits for the rest of an entity: 640 ms in min_latency, 1280 ms in balanced, and 2560 ms in max_accuracy. On our voice-agent benchmark (Universal-3.6 Pro, balanced mode), entity-aware endpointing cuts the phone-number entity error rate from 7.0% to 2.2% and leaves the median end-of-turn latency unchanged. The latency cost falls only on held turns, roughly one turn in ten, so the 90th-percentile end-of-turn latency rises from 0.83 s to 1.64 s. See the Universal-3.6 Pro Realtime research post for the full evaluation.

​
The lifecycle of a turn

Each turn produces a predictable message sequence of one SpeechStarted message, one or more partial Turn messages, and a final Turn message. Every Turn message re-transcribes the full turn audio, so each message supersedes the previous one. Always replace what you have rendered rather than appending. This also means transcripts get more accurate as the turn progresses, since each pass gives the model more audio and more context to work with. For maximum accuracy, use the final transcript marked end_of_turn: true. Use partials where responsiveness matters more than accuracy.

​
SpeechStarted

The server sends SpeechStarted once per turn, immediately before the turn’s first Turn message. It carries the turn’s start timestamp in milliseconds from the start of the audio stream, and the confidence of a new turn starting.
SpeechStarted is only emitted once the model produces an actual transcript, so background noise alone does not trigger it. That makes it a reliable barge-in signal for voice agents. When it arrives, stop your agent’s TTS playback and start listening.

​
Partials

While the speaker talks, the session emits Turn messages with end_of_turn: false.
Partials are emitted at three points.
  • Early partials are emitted shortly after speech begins, timed by the interruption_delay parameter.
  • Pause partials are emitted when a pause triggers an end-of-turn check but the turn reads as incomplete or ends in an entity that may still continue. While an entity hold lasts, they repeat until the turn ends.
  • Continuous partials are emitted roughly every second during uninterrupted speech, so long utterances keep updating even without pauses.
Partials are suited to live captions, barge-in handling, and speculative LLM prefetching, where you want text immediately and can tolerate it being revised.

​
Finals

When the turn ends, the session emits a Turn message with end_of_turn: true. The final is fully formatted, with punctuation, casing, and numbers and entities rendered in written form.
The final is the most accurate transcript of the turn. Send it to your LLM, store it, and act on it whenever accuracy matters.

​
Tuning interruption sensitivity

SpeechStarted and early partials are what trigger interruptions in a voice agent, and two parameters control how eagerly they fire. If quiet or distant speech is being missed, lower vad_threshold so softer audio counts as speech. If background noise or the agent’s own TTS audio is triggering false interruptions, raise vad_threshold so the session requires stronger evidence of speech, increase interruption_delay so it waits longer before emitting the first partial, or enable Voice Focus to suppress background audio before it reaches the model. Like the silence thresholds, both can be set on the connection and updated mid-stream.

​
Capturing entities like phone numbers

Entity-aware endpointing keeps most entities in one turn without any configuration. When your application knows an entity is coming (for example, your voice agent just asked for a callback number) and you want extra margin, raise min_turn_silence mid-stream so that no pause ends the turn early, including a pause after a chunk that doesn’t read as an entity. Afterward, set your mode again to restore the preset’s defaults. Changes take effect immediately, without reconnecting.
A held entity still ends at max_turn_silence. If speakers pause longer than that between chunks, for example while reading a card number off a card, raise max_turn_silence the same way. See Updating configuration mid-stream for the full list of mid-stream parameters.

​
Bring your own turn detection

If you run your own VAD or turn detection model, send a ForceEndpoint message to end the current turn immediately. The server responds with the turn’s final Turn message right away, without waiting for silence.

​
Going further