Voice agent latency benchmark for OpenAI’s Realtime API.

What the numbers show

Turn detection decided how long the caller waited; the model’s share barely moved. In all six settings the model took a median 0.5 to 0.7 seconds from the end of the caller’s turn to its first audio. The wait before that ranged from a median 0.3 s with server VAD to 3.8 s or more with semantic VAD at its default eagerness.

Semantic VAD waited close to its documented timeouts. OpenAI’s API reference gives semantic VAD a maximum timeout of 4 seconds at the default eagerness (auto, which equals medium) and 2 seconds at high. In our run the turn-end event never came more than 4.3 s after the caller’s clip ended at the default eagerness, or 2.3 s at high. At the default eagerness it came 3 s or later in 17 of 30 turns for each model, which suggests the timeout, not the classifier, ended most of those turns.

Under semantic VAD the wait depended on the line. “Tuesday afternoon works. Three thirty, right?” got a reply 1.0 to 1.3 s after the clip ended in all 10 calls at the default eagerness. The opening “Hi, I’d like to book a cleaning, please.” waited 4.6 to 5.2 s in all 10.

The mini model was no slower. Its model time was a median 0.51 to 0.57 s against 0.65 to 0.72 s for gpt-realtime-2.1, and with server VAD its median wait was 0.9 s against 1.0 s. We did not score whether the answers were right; every reply transcript is in the CSV.

Cost followed the model, not the setting. gpt-realtime-2.1 came to $0.0775 to $0.0793 a minute of talk and the mini model to $0.0223 to $0.0229, or about $0.09 to $0.10 and $0.03 per six-turn call. Minutes here are caller plus agent speech, so a model that talks longer spreads its cost over more minutes: the mini model’s replies added up to 275 to 283 seconds per 30 turns, against 236 to 241 seconds for gpt-realtime-2.1.

No setting replied before the caller had finished: in all 180 turns the first reply audio arrived after the caller’s clip ended. Our synthetic caller doesn’t pause mid-sentence the way a person reading out a phone number does, so this run says nothing about how often a 500 ms silence rule cuts in on real callers.

How we measured

We timed each turn of a scripted phone-style call against OpenAI’s Realtime API, the same way for every model and setting.

• When and where. October 26, 2026, 03:06 to 03:51 UTC, from a GitHub-hosted ubuntu-24.04 runner in Azure’s North Central US region, over a server-side WebSocket to the Realtime API.
• Models. gpt-realtime-2.1 and gpt-realtime-2.1-mini, output voice “marin”, no tools, the system prompt below.
• Caller. Six lines booking a cleaning at a made-up dental clinic, voiced once with OpenAI’s gpt-4o-mini-tts (voice “ash”, instructions “A relaxed adult caller on the phone, natural pace.”) and reused for every call: 24 kHz 16-bit mono audio, 2.85 to 6.65 s per clip, each ending 0.2 to 0.6 s after the last word.
• Streaming. Each clip went out at real-time pace in 20 ms chunks, followed by continuous silence until the reply was complete, the way a phone bridge sends audio. The next line started once the caller had heard the whole reply.
• Turn detection. Semantic VAD, default eagerness: { type: "semantic_vad" } (eagerness "auto", equivalent to "medium"); Semantic VAD, eagerness high: { type: "semantic_vad", eagerness: "high" }; Server VAD, 500 ms silence (API default): { type: "server_vad", silence_duration_ms: 500 } (threshold and prefix padding left at their defaults). Per OpenAI’s docs, server VAD is the default for speech-to-speech sessions and 500 ms is its default silence duration.
• Sample. Five calls per model and setting, six turns each: 30 turns per row, 180 in total. Calls ran in five rounds, each round covering every model and setting once, so a slow stretch on the network would touch every row rather than one.
• Timing. Timestamps were taken at our client (Node.js performance.now()) when the last caller chunk was sent, when input_audio_buffer.speech_stopped arrived and when the first response.output_audio.delta arrived. Each median is the mean of the 15th and 16th fastest of the 30 turns; p90 is the nearest-rank value, the 27th.
• Cost. Token usage from each response.done event, priced per 1M tokens at OpenAI’s list prices checked October 26, 2026 (gpt-realtime-2.1: audio $32 in, $64 out; text $4 in, $24 out; cached input $0.40; gpt-realtime-2.1-mini: audio $10 in, $20 out; text $0.60 in, $2.40 out; cached input $0.06), divided by minutes of caller plus agent speech. It is an estimate, not an invoice; all 180 turns came to about $1.91. Our measurement script priced cached audio input on the mini model at the $0.06 rate, where OpenAI lists $0.30; repricing those tokens changes the mini model’s figures by less than $0.0001 a minute.

Test script

The agent’s system prompt, verbatim (the clinic, caller, date of birth and phone number are invented):

You are the phone receptionist for Brightside Dental, a dental clinic in Austin, Texas.
Hours: Monday to Friday, 8am to 5pm. Services: cleanings, fillings, whitening, emergency visits.
Open slots this week: Tuesday 10:00, Tuesday 15:30, Thursday 09:00. New patients need name, date of birth and phone number.
Keep every reply to one or two short sentences, the way a good receptionist talks on the phone. Never invent slots.

The caller’s six lines, with each clip’s length:

1. “Hi, I'd like to book a cleaning, please.” 2.85 s
2. “I'm a new patient. What do you have this week?” 3.60 s
3. “Tuesday afternoon works. Three thirty, right?” 3.30 s
4. “My name is Jordan Miller, date of birth March fourth, nineteen ninety.” 6.65 s
5. “My number is five one two, five five five, zero one four two.” 6.50 s
6. “Great, thank you. That's everything.” 3.25 s

What this benchmark does not show

These numbers describe one controlled setup, and several things a real call adds are left out.

• The phone network. No carrier or telephony provider was in the loop. On a real call their legs add to every turn; the voice agent latency guide budgets them stage by stage.
• What the caller hears. Times are taken when events reached our client, before any playback buffer.
• The last word. The clock starts at the end of each clip, 0.2 to 0.6 s after the caller’s last word. Add that to get the wait from the last word.
• Real callers. One day, one region, one script and a synthetic voice. People pause, mumble, talk over the agent and call from noisy rooms, and all of that changes turn detection.
• Tails. 30 turns per row show the gap between settings clearly, but p90 is the 27th of 30 values, so treat it as rough. We don’t report p95 or p99 for that reason.
• Other stacks. Only OpenAI’s speech-to-speech models: no separate speech-to-text, model and voice pipeline, and no hosted platform.
• Change over time. OpenAI updates its models and defaults. This is a snapshot of October 26, 2026.

What to do with these numbers

Start from OpenAI’s default server VAD if you build on its realtime models, and check it on recorded calls with people who pause while reading out numbers. If it cuts callers off, semantic VAD is the setting to try, at a cost of seconds per turn in our run. Then measure the whole chain on a real phone line.

The AI voice agent pricing tracker puts the per-minute cost next to Vapi, Retell and other platforms, and AI voice agent cost works through the full bill, telephony included. When we build a voice agent, we measure response time on the client’s own call flows before launch; our AI voice agent development page covers what that work includes.

Download the data

voice-agent-latency-2026-10-26.csv holds all 180 turns, one row each, UTF-8 with a header row. It is free to reuse under CC BY 4.0 with a link back to this page. Suggested citation:

Apptycoons, “Voice agent latency benchmark for OpenAI’s Realtime API”, measured October 26, 2026, apptycoons.com/research/voice-agent-latency-benchmark

Run log

Each run keeps its own CSV, so earlier numbers stay downloadable when we add a run.

1. October 26, 2026
   • First run: gpt-realtime-2.1 and gpt-realtime-2.1-mini, three turn-detection settings, 180 turns. CSV

Sources

1. Voice activity detection (VAD), OpenAI API docs (checked October 29, 2026)
2. Realtime API reference: client events (turn detection defaults and eagerness timeouts), OpenAI API reference (checked October 29, 2026)
3. API pricing (realtime and audio models), OpenAI (checked October 26, 2026)