Voice Agent API Cost: a 10-Minute Call Runs $0.04 to $0.57

A 10-minute voice-agent conversation costs between $0.04 and $0.57 in API fees, and the spread comes almost entirely from two decisions: whether you assemble the stack yourself or use a speech-to-speech API, and which text-to-speech tier you pick. We measured every leg through one gateway in one batch: three speech-to-text models by the audio-minute, six text-to-speech models by the audio-minute they actually synthesize, an eight-turn LLM dialog on three brains (two flash-tier, one frontier), and a live GPT Realtime session billed lane by lane. This post assembles those legs into a per-minute price for each architecture.

TL;DR

• A cascade stack (STT + LLM + TTS) runs $0.0037 to $0.025 per conversation-minute; gpt-realtime-2.1 measured $0.057, and the mini at $0.016 lands inside the cascade range.
• With a flash-tier brain the mouth costs more than the brain, 12x in the mainstream build; a frontier brain flips the structure.
• Latency is what the realtime premium buys: 1.7-2.1 s voice-to-voice measured, vs 4.9-7.7 s for the cascade builds.
• Per-character TTS billing makes spoken Chinese 3 to 7x cheaper per audio-minute than English on every model measured.

How does a voice agent work, and why are there two architectures?

A voice agent is a loop that turns the user’s speech into a reply in their ear, and every design on the market is one of two shapes. The cascade wires three specialized APIs in sequence: a voice-activity detector decides the user has finished speaking, speech-to-text transcribes the utterance, an LLM writes a reply from the transcript plus conversation history, and text-to-speech synthesizes it back to audio. Each leg is a separate metered service, which is what makes the cascade cheap and swappable: you pick the STT, the brain, and the voice independently, and you pay three small bills.

The speech-to-speech (realtime) architecture replaces all three legs with one model that consumes and produces audio directly over a WebSocket. (Synthorai carries this natively: the gateway speaks WebSocket at /v1/realtime, and an existing OpenAI Realtime SDK works unchanged pointed at our endpoint; see the realtime API docs. Every realtime session in this post ran over that connection.) Nothing is transcribed in the main path, the model hears tone and timing rather than a transcript, and the conversation history lives server-side as audio tokens that are re-sent to the model on every response. That design buys the two things a cascade structurally cannot deliver, sub-2-second voice-to-voice latency and natural barge-in (the user can interrupt mid-sentence and the model hears it happen), and it changes the billing shape: instead of three flat meters you pay separate audio-in and audio-out rates (the “lanes”) plus a compounding history bill that caching has to keep in check.

The rest of this post prices exactly those two shapes: each cascade leg on its own meter, then the realtime loop lane by lane.

How much does a voice agent cost per minute?

Between $0.0037 and $0.057 per conversation-minute across the six builds we priced, a 15x spread. Two units to keep apart in everything below: a conversation-minute is one minute of wall-clock call time; an audio-minute is one minute of actual speech on one side, which is what STT and TTS meters bill. The scenario, held constant: talk time split evenly between user and agent, four exchanges per minute, short support-style utterances. Cascade legs are billed on measured audio durations and token counts; realtime figures come from a live eight-turn session:

Two placements matter more than the endpoints. The flagship realtime API costs 2.3x even a premium cascade, so what its price buys is not quality parity but the things a cascade cannot do: roughly 2-second voice-to-voice latency in our session, native barge-in, and tone and pacing (prosody) that survive because audio never becomes text. The mini, though, lands between the mainstream and premium cascades, which makes “cascade vs realtime” a real price comparison only at the flagship tier; at the mini tier it is a latency-and-control decision, not a price one.

One fairness check, because the other three cascades run flash-tier brains against OpenAI’s flagship voice model: the SOTA-brain row gives the cascade the same vendor’s frontier text model, gpt-5.6 at $5 in and $30 out per million. Even then the cascade lands at $0.0200 per conversation-minute, 2.9x below flagship realtime, because a text turn at frontier prices still moves two orders of magnitude fewer expensive tokens than an audio lane. Quality parity costs $0.010 of brain per minute; it does not close the architecture gap.

Which leg of the cascade dominates the bill?

The mouth, as long as the brain is a flash-tier model. In the mainstream build, a minute of conversation spends $0.0076 on TTS against $0.0006 on the LLM, a 12x gap; even in the budget build the speak leg is triple the brain. Upgrade the brain to gpt-5.6 and the structure flips: at $0.00274 per exchange, the brain becomes the biggest leg at $0.0110 per minute, 1.4x the tts-1 speak leg. Flash brains make voice agents mouth-dominated; frontier brains make them brain-dominated. Speech-to-text sits in between at $0.0010 to $0.0030 per conversation-minute (per-minute rates from our 14-model sweep, re-verified this batch: qwen3-asr-flash $0.00198, gpt-4o-mini-transcribe $0.00294, whisper-1 $0.006 per audio-minute).

The brain is nearly free until reasoning gets involved. Our eight-turn support dialog reached a steady state of about 310 input and 71 output tokens per turn on deepseek-v4-flash-0731, or $0.00016 per exchange. On gemini-3.7-flash the same dialog cost $0.00126 per exchange, 8x more, and the reason is visible in the token split: 89 to 361 reasoning tokens per turn spent deliberating over a two-sentence reply. Gemini 3.7 Flash cannot turn thinking off, so a voice agent built on it pays a reasoning tax on every exchange; on models where the off switch works, a voice turn is exactly the single-step shape where disabling it is safe.

What does text-to-speech cost per audio-minute?

$0.004 to $0.034 per synthesized minute, an 8.4x spread that per-character price tags hide. Every model below bills per input character, so we synthesized fixed English and Chinese passages, measured the returned audio, and divided:

Speaking rate is the hidden variable. tts-1-hd and chirp3-hd carry the same $30 list price, but chirp3-hd speaks our English passage more quickly in fewer seconds of audio, so it costs 13% more per audio-minute; at the bottom of the table, google-tts-standard delivers a synthesized minute for less than half of anything else measured. The list price ranks the models; only the audio-minute rate prices them.

The Chinese column is the finding we did not expect to be this large: a minute of spoken Chinese consumes 3 to 7x fewer billable characters than a minute of English, because each character carries far more speech. Under per-character billing, the speak leg of a Chinese-language voice agent is 66 to 85% cheaper than the same agent in English, which compounds with the per-language token spreads on the text side.

When is the realtime API worth its price?

When the 2-second voice-to-voice loop and native interruption handling pay for themselves, because on price alone the flagship loses to every cascade we built. Both official audio conversions reproduced exactly in this batch: 30.0 seconds of input audio billed as 300 tokens (1 token per 100 ms) and 3.7 seconds of output as 74 tokens (1 per 50 ms), the same rates our July study measured. At gpt-realtime-2.1 list prices that is $0.0192 per minute just to listen and $0.0768 per minute to speak, before the conversation-history re-billing that makes long sessions compound.

That compounding is tamer than it looks, and the reason is caching. In our eight-turn session, input grew from 72 to 643 tokens per response, but by turn eight 512 of those were cached at $0.40 per million; over the whole session 76% of input tokens billed at the cached rate. The measured all-in figure came to $0.0752 for a 1.31-minute exchange, or $0.0573 per conversation-minute. The lane split of that bill is worth seeing once: 66% audio out, 17% fresh audio in, and 16% text, because the model also emits a text rendering of every reply, billed at the $24-per-million text-output rate. About a sixth of a “speech-to-speech” bill is, in effect, a text model’s invoice. Applying the same measured token profile to mini rates gives $0.0159, and that number is the more interesting one: it undercuts the premium cascade while keeping the latency and barge-in behavior the cascade architecture structurally cannot match.

The remaining realtime tax is operational rather than per-token: sessions hard-stop at 60 minutes and cannot resume with audio history, so anything conversational past that boundary restarts with a cold cache. The July study covers those mechanics in detail.

How much faster is speech-to-speech than a cascade?

Between 2.3x and 4.5x on the builds priced above, and the gap widens as the cascade gets fancier. Same six builds as the cost table, same unit per bar: one conversational turn, measured request-to-response-complete at a realistic shape (5-second utterance in, two-sentence reply out; cascade bars sum per-leg medians of three runs):

In numbers: the cascade turns sum to 4.9 s (budget), 5.6 s (mainstream), 5.7 s (SOTA brain), and 7.7 s (premium), while both speech-to-speech tiers hold the same band, 1.6-2.1 s for gpt-realtime-2.1-mini over 4 live turns and 1.7-2.1 s for gpt-realtime-2.1 over 8.

Read the chart against the cost table and the trade snaps into focus: on the cascade side, money and latency move in opposite directions. The budget build is both the cheapest and the fastest cascade; the premium build pays 6.8x the budget price and is 2.8 seconds slower, because the expensive parts (a deliberating brain, an HD voice) are also the slow parts. On the speech-to-speech side both models hold the same 2-second band regardless of tier, so the mini is simultaneously cheaper than two cascades and faster than all four.

Three more things fall out of the numbers. First, the LLM is the latency bottleneck of every cascade, and mandatory reasoning nearly doubles it: gemini-3.7-flash spends 4.5 seconds deliberating over a two-sentence reply against deepseek’s 2.6 and gpt-5.6’s 2.7, so the same reasoning tax that costs 8x in tokens also buys the premium build its last-place finish. Second, cherry-picking the fastest measured part for every leg (gpt-4o-mini-transcribe, deepseek, google-tts-standard) still floors at 4.1 seconds, more than double the realtime band, before the voice-activity detector’s end-of-speech wait and audio playback are added. Third, cascade rows are sequential, full-response wall times: a production cascade that streams the LLM into a streaming TTS overlaps the two biggest legs and can close much of the gap, but that overlap is engineering you build and tune, while the realtime API’s 2 seconds arrive in the first WebSocket session you open.

Where does a cascade turn’s time actually go? Mostly into the three requests themselves, not the content inside them. The raw network is a minor part: a warm HTTPS round trip to the API edge measured about 0.09 seconds, so three serial legs carry roughly 0.3 seconds of pure network per turn (plus a 0.2-second TLS handshake whenever a connection is cold). The dominant cost is each request’s fixed dispatch, which we isolated by re-running the fastest assembly’s legs with near-empty payloads: a one-token LLM reply still took 2.5 seconds, a half-second clip still took 1.6 seconds to transcribe, and a two-word synthesis took 0.4 seconds. Those floors sum to 4.4 seconds against 4.1 seconds for the full-sized payloads, which is the same number inside measurement noise: essentially all of a cascade turn is per-request overhead, and the actual content (70 reply tokens instead of 1, a 10x longer clip) rides along nearly free. The practical reading cuts both ways: making a cascade’s replies shorter will not make it faster, but anything that removes or overlaps a request (streaming legs into each other, persistent connections) attacks the real cost; the realtime API is the limit case of that logic, holding one socket so a turn never pays a fresh request cycle at all.

FAQ

What is the cheapest way to run a voice agent?

The budget cascade: qwen3-asr-flash for listening, deepseek-v4-flash-0731 for the brain, google-tts-standard for speaking, at $0.0037 per conversation-minute or about $0.04 for a 10-minute call. It is 15x cheaper than flagship speech-to-speech; what you give up is voice-to-voice latency and natural interruption handling.

Is GPT Realtime more expensive than a cascade stack?

The flagship is: gpt-realtime-2.1 measured $0.0573 per conversation-minute, 2.3x our premium cascade and 15x the budget one. gpt-realtime-2.1-mini is not: at $0.0159 per conversation-minute on the same token profile, it sits between the mainstream and premium cascades, so at the mini tier the choice is about latency and control rather than price.

Which part of a voice agent costs the most?

Text-to-speech, in every flash-brain cascade we priced: $0.002 to $0.017 per conversation-minute against $0.0006 to $0.005 for a flash LLM, 12x in the mainstream build. A frontier brain flips it, with gpt-5.6 at $0.0110 per minute against tts-1’s $0.0076. Within TTS, model choice spans 8.4x per audio-minute, the biggest single lever measured.

Does the language of the conversation change the cost?

For the speak leg, dramatically: per-character billing makes a minute of spoken Chinese 3 to 7x cheaper than English on all six TTS models measured, because each character carries more speech. Speech-to-text rates were flat across the two languages on the three models we re-verified, and the text-side differences follow per-language tokenizer spreads.

Measured 2026-08-17 through the Synthorai gateway, all legs in one batch: six TTS models synthesizing fixed English and Chinese passages with audio durations read from the returned files (two runs each); three STT models on the standard fixture clips with per-minute cost from billing headers; an eight-turn scripted support dialog on three LLM brains (two flash-tier, one frontier) with per-turn usage recorded; a per-leg latency probe (5-second utterance to STT, steady-state dialog turn to the LLM, two-sentence reply to TTS, n=3, full-response walls), a minimal-payload floor probe on the same legs (one-token reply, half-second clip, two-word synthesis, n=3) with warm and cold round-trip timing to the API edge, and live GPT Realtime sessions (5-second utterances, eight turns on the flagship, four on the mini) billed lane by lane from response.done usage events, with the mini cost figure derived by applying the flagship session’s measured token profile to mini list rates and the mini latency band measured from its own session. Cascade composites assume talk time split evenly and four exchanges per minute; rates are list prices from the model catalog at measurement time. seed-tts-2.0 is onboarded but excluded pending stable measurements. Prices and speaking rates change; re-measure before committing to an architecture.

Related, same series: speech-to-text pricing across 14 models, GPT Realtime pricing mechanics, image input token costs, video generation pricing.

← Back to blog