Gemini Live API pricing: why a long conversation costs more per minute
Google publishes Gemini Live rates per token, and the per-minute figures on the pricing page cover only fresh audio. Each turn also re-bills the conversation so far, so the bill grows faster than the clock.
The rate card
Google prices Gemini 3.8 Live, Gemini 3.8 Live Extended Thinking and Gemini 3.1 Flash Live Preview in one section of its pricing page. The three models share these paid-tier rates. The free tier is free of charge.
| Meter | Per 1M tokens | Google's per-minute equivalent |
|---|---|---|
| Audio input | $3.00 | $0.005/min |
| Audio output | $12.00 | $0.018/min |
| Text input | $0.75 | none given |
| Text output, including thinking tokens | $4.50 | none given |
| Image or video input | $1.00 | $0.002/min |
| Grounding with Google Search | 5,000 free search requests per month, shared across Gemini 3 and newer models, then $14 per 1,000 | |
The minute figures follow from the token rate. Google's Live API best practices put native audio at about 25 tokens per second, or 1,500 per minute. At $3/M that is $0.0045 a minute of input, which the pricing page rounds to $0.005. At $12/M it is $0.018 a minute of output.
The older Gemini 2.5 Flash Native Audio model has the same audio rates but cheaper text: $0.50/M in and $2.00/M out. Pin the model name in your config and your cost sheet. A 2.5 price applied to a 3.8 session gets the text lines wrong.
Every turn re-bills the conversation
The best-practices page states the rule plainly. The API "charges you per turn for all tokens present in the session context window," and a turn is one user input plus the model's response. Past tokens are "re-processed and accounted for in each new turn, up to your configured context window size."
Gemini keeps that history as raw audio tokens, and it bills them "at the standard audio input rate on every turn." The model's own earlier replies come back as input audio on the next turn. So the per-minute equivalents above are a floor. They price each second of sound once, and a long session pays for most seconds many times.
An illustrative 10-minute session
Take a 10-minute conversation of 20 turns. In each turn the user speaks for 15 seconds and the model answers for 15 seconds. That is 375 tokens each way per turn at 25 tokens per second. Turn 1 sends 375 input tokens. Turn 20 sends the 14,250 tokens of history plus 375 new ones.
| Counting method | Input tokens | Input cost | Output cost | Total |
|---|---|---|---|---|
| Fresh audio only (per-minute rates) | 7,500 | $0.023 | $0.090 | $0.113 |
| Retained context re-billed each turn | 150,000 | $0.450 | $0.090 | $0.540 |
Output audio is billed once, so the gap is all on the input side. Each new turn carries every turn before it, so re-billed input grows with the square of the turn count: twice the turns, about four times the input.
Without compression this session cannot run much longer anyway. Google's session management guide limits audio-only sessions to 15 minutes and audio-video sessions to 2 minutes unless context window compression is on.
Compression caps the bill and forgets the start
Context window compression is what lets a session run past 15 minutes, and it is also the main cost control. The API reference gives two numbers. triggerTokens sets the context size that starts a compression, and defaults to 80% of the model's context window. slidingWindow.targetTokens sets how much survives, and defaults to half the trigger.
The sliding window drops the oldest turns. System instructions stay. Google's best-practices example uses a 25,000-token trigger and an 8,000-token window, after which "subsequent turns" are billed "only for the retained history plus any new tokens."
| Configuration | Input tokens billed | Audio total | Per minute |
|---|---|---|---|
| No compression | Not possible: the audio-only session ends at 15 minutes | ||
| Trigger 25,000, keep 8,000 | 843,250 | $2.80 | $0.093 |
| Trigger 10,000, keep 4,000 | 409,750 | $1.50 | $0.050 |
| Fresh audio only, for reference | 22,500 | $0.34 | $0.011 |
A smaller window costs less and remembers less. With a 4,000-token window the model holds under three minutes of two-way audio. Anything the user said before that is gone unless your application stored it and sends it back. The API reference also warns that each compression adds a temporary latency increase, so a tiny trigger that fires every few turns has a cost you hear.
Listening is billed on Gemini 3.8
Proactive audio lets the model stay quiet when speech is not meant for it. When it is on, Google "charges for input tokens the entire time the Live API is listening," and for output only when the model responds. The best-practices page says proactive audio is permanently enabled in gemini-3.8-live and gemini-3.8-live-extended-thinking. It is not supported on gemini-3.1-flash-live-preview, which bills audio only while you actively stream input.
On 3.8, an open microphone in a quiet room is a meter running at about $0.005 a minute, or $0.30 an hour, before any context re-billing. The examples above leave silence out. Google does not say whether listened-to silence also enters the retained context. Log promptTokensDetails on a silent stretch of your own session to find out.
Transcription, thinking and search
Turning on inputAudioTranscription or outputAudioTranscription adds a charge for every transcript token at the text output rate, $4.50/M, on top of the audio. Google gives no tokens-per-minute figure for Live transcripts. Its separate Live Transcribe model is estimated at 175 text tokens per minute. Borrowing that figure, transcribing both sides of the 10-minute example (10 minutes of speech) adds about 1,750 tokens, or under one cent. Transcription is small next to context re-billing.
Extended Thinking bills its reasoning as text output at $4.50/M. The number of thinking tokens per turn depends on the request, so measure it from thoughtsTokenCount rather than guessing.
Search grounding is priced per search query, not per prompt. The pricing page notes that one request "may result in one or more queries to Google Search," each charged. Past the shared 5,000 free requests a month, each query costs $0.014.
What to log
Every server message can carry a usageMetadata block. Store it per turn with the model name and your compression settings. The fields that rebuild a bill are promptTokenCount, responseTokenCount, thoughtsTokenCount, toolUsePromptTokenCount and the per-modality lists in promptTokensDetails and responseTokensDetails. Multiply audio and text tokens by their own rates. A calculator built on the rounded per-minute figures will undercount any session longer than a few turns.
Reconnecting does not reset the meter. Session resumption carries the context to the new connection, and with it the re-billing.
Where a flat session rate fits
Token billing makes the voice cost depend on how many turns a user takes and how much history you keep. A connected-minute rate does not. Duplex Compute prices voice sessions at $0.01 per connected minute, so 30 minutes is $0.30 whatever the turn count. That is the voice-session line only. Tools, your backend model and transport still add their own costs, and the totals across providers belong in the voice agent pricing hub. Rates for Gemini, Grok and .wave sit side by side in the live API pricing reference.
Related notes
- Voice agent pricing: calculator and billing formulas
- Gemini Live session resumption
- Live voice API pricing: Gemini, Grok and Nemotron
- GPT-Live vs. Realtime API
- What an hour of voice conversation costs
Need a voice bill that does not grow with history?
Duplex is a full-duplex voice API with tool calling, priced per connected minute. Tell us your expected voice hours, the tools your agent calls and the provider you use now.
Request access