Ten minutes of speech-to-speech conversation costs $6.90 in model tokens when prompt caching misses and $0.93 when it holds — a 7.4× spread on identical audio. Run as a cascade of Deepgram Nova-3, gpt-5.6-luna and Aura-2, the same conversation costs $0.22. Architecture sets the bill, not the rate card.
Every price on this page was read on the vendor’s own pricing page on 10 September 2026 and is linked at the point of use. None of the three pricing pages we read — OpenAI, Deepgram or Twilio US voice — prints a currency code beside a price in its visible tables, so read every bare “$” below as unconverted. Two of the three do declare one in markup a reader never sees: Deepgram tags every offer "priceCurrency":"USD" in the schema.org product data embedded in its pricing page, and Twilio’s US page carries data-currency-code="usd" on the pricing section. On OpenAI’s page we could locate no currency code in either the visible text or the page source (read 10 September 2026). Deepgram’s page carries a price step-up dated 13 September 2026, three days after this was written; that section is flagged below.
What does an AI voice agent actually cost per minute?
There is no single per-minute number, and any page that gives you one has guessed at the inputs. The Realtime API bills tokens, not minutes. OpenAI’s cost guide states plainly: “Realtime API costs are accrued when a Response is created, and is charged based on the numbers of input and output tokens (except for input transcription costs, see below)”. A per-minute figure is an output of your call shape, not an input you can look up.
These are the published units the arithmetic on this page is built from. Prices are per 1M tokens unless the row says otherwise.
| Vendor | Product | Unit | Published price |
|---|---|---|---|
| OpenAI | gpt-realtime-2.1, audio | per 1M tokens | input $32.00, cached input $0.40, output $64.00 |
| OpenAI | gpt-realtime-2.1, text | per 1M tokens | input $4.00, cached input $0.40, output $24.00 |
| OpenAI | gpt-realtime-2.1-mini, audio | per 1M tokens | input $10.00, cached input $0.30, output $20.00 |
| OpenAI | gpt-realtime-2.1-mini, text | per 1M tokens | input $0.60, cached input $0.06, output $2.40 |
| OpenAI | gpt-5.6-luna (text LLM, short context — OpenAI defines this as 272K input tokens or fewer) | per 1M tokens | input $0.20, cached input $0.02, output $1.20 |
| OpenAI | gpt-4o-transcribe / gpt-4o-mini-transcribe | per minute | $0.006 / $0.003 |
| Deepgram | Nova-3 Monolingual streaming (Pay As You Go) | per minute | $0.0048/min (page also shows a regular price of $0.0077/min) |
| Deepgram | Flux English streaming (Pay As You Go) | per minute | $0.0065/min (regular price $0.0077/min) |
| Deepgram | Aura-1 / Aura-2 / Flux TTS (Pay As You Go) | per 1k characters | $0.0150 / $0.030 / free until 9/12 then $0.0450 |
| Deepgram | Voice Agent API, Standard (Pay As You Go) | per minute | $0.056/min through 9/12, then $0.075/min |
| Twilio | Outbound call, United States & Canada | per minute | $0.0140/min |
| Twilio | Inbound to a local number | per minute | $0.0085/min plus $1.15/mo per number |
| Twilio | Media Streams | per minute | $0.0044/min |
| Twilio | ConversationRelay | per minute | $0.07/min |
Two of those rows are the entire subject of this page: OpenAI charges $32.00 per 1M audio input tokens and $4.00 per 1M text input tokens on the same model. Audio input costs eight times what text input costs, and a minute of speech carries far more audio tokens than text tokens. That gap is invisible on turn one and decisive on turn thirty.
Why does minute 8 of my call cost more than minute 1?
Because the whole conversation is re-billed on every turn. OpenAI publishes the mechanism in its Realtime API cost guide, read 10 September 2026:
The entire conversation is sent to the model for each Response. The output from a turn will be added as Items to the server Conversation and become the input to subsequent turns, thus turns later in the session will be more expensive.
And it publishes the conversion that turns seconds into tokens:
Audio tokens in user messages are 1 token per 100 ms of audio, while audio tokens in assistant messages are 1 token per 50ms of audio.
Call this the turn tax: on a speech-to-speech model, every second of audio you have already paid to receive and every second you have already paid to generate is bought again, as input, on every subsequent turn. It is not a hidden fee. It is the ordinary consequence of a stateless model with a growing context, and it is arithmetic anyone can do.
The worked calculation, with the inputs stated
These are our assumptions, not vendor claims. Substitute your own.
- System instructions: 800 text tokens, constant, sent every turn.
- A turn: the caller speaks 6 seconds, the agent replies for 9 seconds. That is 15 seconds, so four turns per minute and 40 turns in a ten-minute call.
- Caller audio: 6 s at 1 token per 100 ms = 60 audio tokens.
- Agent audio: 9 s at 1 token per 50 ms = 180 audio tokens.
- Agent text: 59 text tokens. Derived from OpenAI’s own usage example on the same page, which shows one assistant message billed as 91 audio tokens against 30 text tokens; 180 × 30 ÷ 91 = 59.3.
- Model: gpt-realtime-2.1 at the rates in the table above.
- What “caching holds” means here: on each turn we bill the previous Response’s input tokens at the cached rate and everything else at full rate — including the assistant’s own audio and text output from the turn before, which was generated as output and had not previously been billed as input. That is the conservative reading of a best-effort cache, and it is the assumption behind every “caching holds” figure below.
So the input to turn n is 800 + 59(n-1) text tokens and 240(n-1) + 60 audio tokens, and the output is always 180 audio + 59 text tokens.
Check the model against OpenAI’s own worked example before trusting it. The cost guide walks through a session with 100 tokens of instructions, a 20-audio-token user message, an assistant reply of 20 audio and 10 text tokens, then a second user message of 25 audio tokens. It states: “This turn will have 110 text and 64 audio tokens for input”. Our formula gives 100 + 10 = 110 text, and 20 + 20 + 25 = 65 audio. The text figure matches exactly; the audio figure is one token out, and we cannot reconcile it. OpenAI notes on the same page that “token counts include special tokens aside from the content of a message which will surface as small variations in these counts”, but the example it gives is a count running high, not low, so we have not adjusted for it. A model that reproduces the vendor’s published example to within one token is a model you can substitute your own numbers into.
What that costs, minute by minute
Turn 1 sends 860 tokens to the model. Turn 32 — the last turn of minute 8 — sends 10,129, of which 7,500 are audio input tokens at $32.00 per 1M. Nothing about the conversation has changed except its length.
| Minute of call | Speech-to-speech, caching misses | Speech-to-speech, caching holds | Cascade (Nova-3 + gpt-5.6-luna + Aura-2) |
|---|---|---|---|
| 1 | $0.1197 | $0.0820 | $0.0216 |
| 2 | $0.2464 | $0.0869 | $0.0215 |
| 3 | $0.3730 | $0.0889 | $0.0215 |
| 4 | $0.4997 | $0.0908 | $0.0215 |
| 5 | $0.6263 | $0.0927 | $0.0216 |
| 6 | $0.7530 | $0.0946 | $0.0216 |
| 7 | $0.8797 | $0.0965 | $0.0216 |
| 8 | $1.0063 | $0.0984 | $0.0217 |
| 9 | $1.1330 | $0.1003 | $0.0217 |
| 10 | $1.2596 | $0.1022 | $0.0217 |
| 10-minute total | $6.8967 | $0.9333 | $0.2159 |
Model legs only; the carrier leg is added further down. Minute 8 costs 8.4 times minute 1 when prompt caching misses, and 1.2 times minute 1 when it holds. On the cascade, minute 8 costs 1.004 times minute 1 — the turn tax exists there too, and it is too small to see.
Caching is the single largest driver, and OpenAI says it is not guaranteed
Cached audio input is priced at $0.40 per 1M tokens against $32.00 uncached: one eightieth. That one row decides most of the bill. OpenAI’s guidance on whether you will get it is explicit:
Caching applies when the input tokens of a Response match tokens from a previous Response, though this is best-effort and not guaranteed.
The same page names what breaks it: “Removing or changing content in the conversation will ‘bust’ the cache up to the point of the change — the input no longer matches as much as before”, and “instructions and tool definitions are at the beginning of a conversation, thus changing these mid-session will reduce the cache rate for subsequent turns”. So an agent that injects a retrieved knowledge-base passage at the top of the prompt, or rewrites its instructions when the conversation changes topic, is choosing the $6.90 column over the $0.93 column. Anyone designing that behaviour should read our note on retrieval latency in mid-call knowledge lookups alongside this, because the same design decision moves both numbers.
How much you can save turns on one modelling question the guide does not settle: whether the assistant’s own output audio is cached for the next turn. OpenAI says only that “The messages from the first turn are likely to be cached for turn 2”. We have assumed it is not, which is the conservative choice. On the looser assumption — the whole prior turn, output included, cached at $0.40 — the ten-minute cached leg falls from $0.9333 to $0.7032 and minute 8 costs 1.16 times minute 1 rather than 1.2. Every conclusion on this page holds under either reading; the cascade is still cheaper at $0.2159.
Truncation is the other end of the same mechanism. OpenAI states that “A 32k context model with 4,096 max output tokens can only include 28,224 tokens in the context before truncation occurs”, and warns that “Truncation busts the cache near the beginning of the conversation, and if truncation occurs on every turn then cache rate will be very low.” On the inputs above the conversation grows by 299 tokens per turn, so a 32k model reaches that ceiling at roughly turn 93 — about 23 minutes of talk. Calls that run past twenty minutes hit the worst of both: a large context and a cache that is being busted on every turn.
Is speech-to-speech cheaper than STT plus LLM plus TTS?
On these published rates, no, and not at any call length. The cascade is cheaper by 4.3 times even when caching holds on every turn of the speech-to-speech session (3.3 times on the looser cache assumption set out above), and by 32 times when it does not. What you buy with the difference is latency and prosody, not price — which is a real thing to buy, and the reason to read why sub-second voice AI latency matters before optimising the bill.
The carried-context test
Here is the decision rule, and it is one sentence: before you compare per-minute rates, ask what currency your conversation history is carried in. Every architecture re-sends the conversation. The only question is whether it re-sends it as audio tokens or as text tokens.
The table below prices one thing: re-sending a single minute of the caller’s speech to the model, once, as context. The text-token count of 396 is derived from the same OpenAI usage example used above (30 text tokens for 4.55 seconds of speech, so 6.6 text tokens per second). That figure is generous — it over-states how many tokens a transcript really needs — which biases this table against the cascade, not for it.
| Carried as | Model and rate | Tokens | Cost to re-send once |
|---|---|---|---|
| Audio, uncached | gpt-realtime-2.1 audio input, $32.00/1M | 600 | $0.01920 |
| Audio, cached | gpt-realtime-2.1 cached audio, $0.40/1M | 600 | $0.00024 |
| Text, same model | gpt-realtime-2.1 text input, $4.00/1M | 396 | $0.00158 |
| Text, cheap LLM | gpt-5.6-luna text input, $0.20/1M | 396 | $0.00008 |
The same minute of conversation history costs 242 times more to carry as uncached audio on a realtime model than as text on a small text model. That ratio, not the headline per-minute rate, is what separates the two architectures on a long call.
What the cascade legs actually cost
The cascade in the table above is Deepgram Nova-3 Monolingual streaming for speech-to-text at $0.0048/min, gpt-5.6-luna for the reply, and Deepgram Aura-2 for speech at $0.030 per 1,000 characters. Speech-to-text bills the whole call because you stream continuously; the LLM bills a text context that grows by 99 tokens per turn; text-to-speech bills only the characters the agent actually says. The split over ten minutes is the surprise: speech-to-text $0.048, text-to-speech $0.162, and the language model $0.0059. On a cascade the LLM is 2.7% of the model bill; on a speech-to-speech session it is all of it.
Text-to-speech is the one leg where you must supply your own input, because every vendor prices it per character and no vendor prices a character rate per minute of speech. We use 900 characters per minute of agent speech in the worked example. Here is the sensitivity, per minute of agent speech — on the 6-second-in, 9-second-out turn above, the agent speaks for 36 seconds of every call minute, so multiply by 0.6 to get a per-call-minute figure.
| Characters per minute of agent speech | Aura-1 at $0.0150/1k | Aura-2 at $0.030/1k | Flux TTS at $0.0450/1k (from 13 Sep 2026) |
|---|---|---|---|
| 700 | $0.0105 | $0.0210 | $0.0315 |
| 900 | $0.0135 | $0.0270 | $0.0405 |
| 1,100 | $0.0165 | $0.0330 | $0.0495 |
Caching matters far less here, and that is the point. Across the whole ten-minute call the cascade costs $0.2159 with a warm LLM cache and $0.2350 with none — a spread of 9%. The speech-to-speech spread on the same call is 7.4 times. Prompt caching moves a cascade bill by 9% and a speech-to-speech bill by 639%.
What does the carrier leg add, and what do people forget?
Every architecture above still needs a phone call. Twilio’s US voice pricing page, read 10 September 2026, publishes outbound United States and Canada calling at $0.0140/min, so ten minutes of talk is $0.14 before a single token is spent. Inbound to a local number is $0.0085/min plus $1.15 per month for the number, and inbound to a toll-free number is $0.0220/min plus $2.15 per month — inbound toll-free costs more per minute than outbound, which quietly inverts the economics of an inbound receptionist against an outbound agent.
The forgotten line is Media Streams at $0.0044/min. If your architecture pulls audio off the carrier and into your own pipeline — which is exactly what a cascade does — that meter runs for the whole call. Ten minutes is $0.044, which is 20% of the entire cascade model cost. Twilio’s fully managed alternative, ConversationRelay, is published at $0.07/min, or $0.70 for the same ten minutes, against $0.21 for the Deepgram speech-to-text and text-to-speech legs it would replace.
| Ten-minute outbound US call, all legs | Model / platform | Carrier | Media Streams | Total |
|---|---|---|---|---|
| Speech-to-speech, caching misses | $6.8967 | $0.1400 | — | $7.04 |
| Speech-to-speech, caching holds | $0.9333 | $0.1400 | — | $1.07 |
| Speech-to-speech on gpt-realtime-2.1-mini, caching holds | $0.3043 | $0.1400 | — | $0.44 |
| Cascade (Nova-3 + gpt-5.6-luna + Aura-2) | $0.2159 | $0.1400 | $0.0440 | $0.40 |
| Deepgram Voice Agent API, Standard, through 12 Sep 2026 | $0.5600 | $0.1400 | — | $0.70 |
| Deepgram Voice Agent API, Standard, from 13 Sep 2026 | $0.7500 | $0.1400 | — | $0.89 |
Carrier rounding sits on top of all six rows and is a separate subject; we have walked it through in detail in why an AI voice agent bill beats minutes times rate, and the question of which dials you pay for at all is covered in what unanswered AI calls cost you. Neither of those mechanics changes the ordering of this table; they scale it.
What changes on 13 September 2026
Deepgram’s pricing page, read 10 September 2026, carries a dated step-up. Its text-to-speech section states:
Through September 12, 2026, developers can build with Flux TTS free with up to 45 concurrent streaming connections globally (5 in EU/AU). Standard pricing applies beginning September 13, 2026.
The Voice Agent API rows carry the same date in shorthand: Standard is listed at “$0.056/min through 9/12 Then $0.075/min”, Custom BYO LLM at “$0.050/min through 9/12 Then $0.065/min”, and Advanced at “$0.122/min through 9/12 Then $0.163/min”. That is a 33.9% increase on the Standard tier, landing three days after this page was written. Any comparison built on the current number is out of date this weekend. This is the ordinary condition of the category, not a criticism of Deepgram, and it is why every price on this page carries the date it was read.
One structural detail on that tier is worth more than the rate itself. Every Voice Agent API row on the page is annotated “calculated based on websocket connection time”. That is a different meter from the token meter. A connection-time meter bills silence, hold music and the caller thinking; the token meter does not, because OpenAI’s guide states that “VAD will effectively filter out empty input audio, so empty audio doesn’t count as input tokens unless the client manually adds it as conversation input”. On a call that is 30% dead air, connection-time billing charges for the dead air and token billing does not. Match the meter to your call shape before you compare the rates.
Which architecture should I choose, and when
The honest answer is that most teams should start with a cascade, and the arithmetic above is why. The threshold table below is our reading of it; every row is a decision you can check against your own call logs today.
| If this is true of your calls | Choose | Because |
|---|---|---|
| Calls run under about 2 minutes and turns are short | Speech-to-speech is affordable | The turn tax is small early. Minutes 1 and 2 together cost $0.37 uncached, $0.17 cached |
| Calls routinely run past 8 minutes | Cascade | Minute 8 costs 8.4 times minute 1 on an uncached speech-to-speech session and 1.004 times on a cascade |
| The prompt changes mid-call (retrieval, tool definitions, topic switches) | Cascade | Cache busting moves the speech-to-speech bill by 7.4 times and the cascade bill by 9% |
| Calls run past about 23 minutes on a 32k-context model | Cascade, or hard-cap the context | Truncation starts at 28,224 tokens and busts the cache on every subsequent turn |
| Calls contain long silences, hold time or IVR navigation | Token-metered, not connection-metered | VAD filters empty input audio out of the token count; websocket connection time bills it |
| Interruption handling and prosody are the product | Speech-to-speech, and budget for it | The cascade is cheaper on every row above and slower on the one that matters to the caller |
| Under roughly 500 calls a month, one language, one script | Build it yourself | At $0.40 a ten-minute call the model bill is not the constraint; your engineering time is |
| Thousands of calls a month across languages, with follow-up, CRM writes and compliance logging | Buy a platform | The per-minute rate stops being the dominant cost long before the orchestration does |
That last row is where the arithmetic stops being useful. Everything on this page prices a single call in isolation. It does not price retries, the follow-up sequence that converts the call that did not connect, split-testing the script, or writing the outcome back into a CRM — and on a real campaign those decide the cost per booked meeting far more than $0.40 against $7.04 does. That orchestration layer is what Zian AI’s autonomous sales agent solutions are built around: SmartReach AI orchestrates message, channel and timing, PrecisionPitch AI split-tests scripts against real outcomes, across 30+ languages, with private model deployment available on customer infrastructure. Zian is in partnership-application beta, publishes no pricing, and has no free trial and no self-serve signup — which is why this page prices the category rather than our own product. If you are buying in Australia rather than the US, our companion piece on how to read AI phone agent pricing in Australia covers the same ground in Australian dollars.
What this page does not price
Five honest gaps, so you can close them yourself.
- Input transcription. If you enable transcription on a Realtime session, OpenAI states it “uses a different model than the speech2speech model, such as
whisper-1orgpt-4o-transcribe, and thus are billed from a different rate card”. At $0.006/min that is $0.06 on a ten-minute call — small, and absent from the tables above. - OpenAI text-to-speech as a cascade leg. The pricing page lists gpt-4o-mini-tts audio output at $12.00 per 1M tokens, but we could not locate a published tokens-per-second rate for that model on developers.openai.com/api/docs/pricing (read 10 September 2026), so we cannot convert it to a per-minute figure honestly and have not tried. Deepgram’s per-character pricing is used instead because it converts cleanly.
- Concurrency and subscription lines. Deepgram’s Pay As You Go tier lists up to 45 concurrent Voice Agent websocket connections; Twilio charges $1.15 per month per local number. Neither scales with minutes and neither appears in a per-minute comparison.
- The speaking rate. Characters per minute of agent speech is the one input we could not locate on any of the four vendor pages cited here (read 10 September 2026), which is why it appears as a sensitivity table rather than as a fact.
- The calls that never connect. On an outbound campaign these outnumber the connected ones, and none of the rate cards above prices them.
Where every figure on this page comes from
Who owns each figure, on which page, and the date we opened it. No summarisers, no comparison blogs, no listicles.
| Figure used here | Owner (organisation) | Source page | Date checked |
|---|---|---|---|
| gpt-realtime-2.1 audio $32.00 / $0.40 cached / $64.00; text $4.00 / $0.40 / $24.00; gpt-realtime-2.1-mini audio $10.00 / $0.30 / $20.00 and text $0.60 / $0.06 / $2.40; gpt-5.6-luna $0.20 / $0.02 / $1.20; gpt-4o-transcribe $0.006/min; gpt-4o-mini-tts audio output $12.00/1M | OpenAI | developers.openai.com/api/docs/pricing | 10 September 2026 |
| 1 token per 100 ms (user audio) and 1 token per 50 ms (assistant audio); the entire conversation re-sent per Response; caching best-effort and not guaranteed; 28,224-token truncation ceiling; VAD filtering of empty audio; the 110-text / 64-audio worked example | OpenAI | developers.openai.com/api/docs/guides/realtime-costs | 10 September 2026 |
| Nova-3 Monolingual $0.0048/min; Flux English $0.0065/min; Aura-1 $0.0150/1k chars; Aura-2 $0.030/1k chars; Flux TTS free until 9/12 then $0.0450/1k chars; Voice Agent API Standard $0.056/min then $0.075/min; the 13 September 2026 changeover; websocket connection-time billing | Deepgram | deepgram.com/pricing | 10 September 2026 |
| US outbound $0.0140/min; local inbound $0.0085/min plus $1.15/mo; toll-free inbound $0.0220/min plus $2.15/mo; Media Streams $0.0044/min; ConversationRelay $0.07/min | Twilio | twilio.com/en-us/voice/pricing/us | 10 September 2026 |
| Evidence that this question is actually being asked | OpenAI Developer Community | Estimate the cost for 1 min usage of Real-time API | 10 September 2026 |
| Turn shape (6 s in, 9 s out), 800-token instructions, 900 characters per minute of agent speech, and every per-minute total in the tables above | Zian AI (this page) | Calculated from the rows above; method and every input stated in the worked-calculation section | 10 September 2026 |
Frequently asked questions
How much does the OpenAI Realtime API cost per minute?
It depends on how far into the call you are. On the worked example above, minute 1 of a gpt-realtime-2.1 session costs $0.1197 in tokens and minute 10 costs $1.2596 if prompt caching misses, or $0.0820 and $0.1022 if it holds. The unit prices are published on the OpenAI pricing page, read 10 September 2026: audio input $32.00 per 1M tokens, cached audio input $0.40, audio output $64.00. Any single per-minute number is an assumption about call shape.
Is speech to speech cheaper than STT plus LLM plus TTS?
Not on the published rates we read on 10 September 2026. A ten-minute call costs $0.2159 in model legs as a cascade of Deepgram Nova-3, gpt-5.6-luna and Aura-2, against $0.9333 for speech to speech with prompt caching holding and $6.8967 with it missing. The cascade is cheaper by between 4.3 and 32 times. What speech to speech buys is lower latency and better prosody, not a lower bill.
Why did my second minute cost more than my first?
Because the model is re-sent the whole conversation on every turn. The OpenAI cost guide states that the entire conversation is sent to the model for each Response, and that turns later in the session will therefore be more expensive. Audio is the expensive way to carry that history: user audio bills at 1 token per 100 ms and assistant audio at 1 token per 50 ms, so a minute of talk becomes 600 to 1,200 tokens that get bought again on every subsequent turn.
Does prompt caching guarantee the lower price?
No. OpenAI describes caching as best-effort and not guaranteed, and states that removing or changing content in the conversation busts the cache up to the point of the change. Injecting retrieved content or rewriting instructions mid-session is enough to lose it. On our worked example the difference between a held cache and a missed one across ten minutes is $0.93 against $6.90.
Am I billed for silence on a voice agent call?
It depends which meter you are on. Deepgram annotates every Voice Agent API rate on its pricing page as calculated based on websocket connection time, which runs through silence. OpenAI states that voice activity detection filters out empty input audio, so silence does not become input tokens on a Realtime session unless the client adds it deliberately. Carrier time bills regardless, at $0.0140 per minute for a US outbound call on Twilio.
What is the cheapest way to run an AI voice agent per minute?
On the rates we read on 10 September 2026, a cascade of streaming speech-to-text, a small text model and per-character text-to-speech, at about $0.40 for a ten-minute US outbound call including carrier and Media Streams. A managed Voice Agent API costs $0.70 for the same call and $0.89 from 13 September 2026. Uncached speech to speech costs $7.04. Cheapest per minute is not the same as cheapest per booked meeting.
Where are people asking this question?
The OpenAI developer forum carries a running thread titled Estimate the cost for 1 min usage of Real-time API, which is exactly the question this page answers. The reason it recurs is that the answer is a formula rather than a number, and the formula is published but rarely worked through.
Zian AI is in a partnership-application beta. Autonomous agents for outbound appointment setting, support and call closing across phone, SMS, email and WhatsApp, in 30+ languages, with private model deployment available on customer infrastructure. Apply For Partnership