Check this call

  • ✓See whether this session is GPT-Live or the Realtime API. Live reconciles to the final usage.seconds. Realtime reconciles to the tokens on each response.done.
  • ✓Live session.usage.updated is a cumulative snapshot. The next one replaces the last. Do not add the pushes together. After close, record session.closed once.
  • ✓Creating a WebRTC session bills 15 seconds. Once the session is running, those seconds are already in the duration. Do not add them again. Count the create charge for reconnects and for sessions opened before anyone speaks.
  • ✓Audio, text and image on a Realtime Response are details inside the input or output total. Cached tokens are a subset of input. Do not add a transcription event on top of that Response.
  • ✓A later turn's input includes the previous turn's output. Changing instructions or tools mid-session breaks the cache back to the edit. Truncation drops the oldest items and the cache near the start.

1. One page, two voice meters

The cost page describes GPT-Live first and the Realtime API second. They do not share a ruler. Live splits the voice session from the backend that reasons and runs tools: voice is seconds, the backend is the models and tools you actually call. A conversational Realtime session bills input and output tokens on each Response, across text, audio and image. Streaming translation and streaming transcription do not use that Response lifecycle. They bill by audio duration. Unit prices stay on the model pages. This article does not freeze one day's number into a standing rate.

The word realtime is easy to merge with the wrong product. In the batch article, realtime means the synchronous API next to the half-price batch window, not this voice session. Domestic speech synthesis bills characters, which is another ruler. Reconcile by whether the call was a Live session, a Realtime Response, or a separate transcription or translation stream.

2. Silence still spends seconds while the session is open

GPT-Live voice is billed per second at the current model rate. The page says duration is not rounded up to the next minute. Active time includes the user speaking, the assistant speaking, both sides silent, and the backend still working. For an estimate, count from start through closure, and use the duration the API reports rather than only the audio you played locally. Muting the microphone does not close the session. When the conversation is finished, close it and keep the final usage.

A POST /v1/live/sessions request bills 15 seconds while a WebRTC session initializes. Once the session is running, that amount is credited against the duration charges. The page's example is a 90-second session that already includes the 15 seconds. It is not billed as 105. Creating a session before the user is ready, or reconnecting over and over, has to include that create charge. The credit applies after the session starts running. Adding create and run as two full charges counts the same initialization twice.

session.usage.updated reports cumulative seconds. Each update replaces the previous snapshot. Do not sum them. After session.close, keep reading events until session.closed and record that final figure once. Backend calls are a separate column from voice seconds. For delegated Responses, read nested response.completed events and count each response id once, keeping input, output and cached details for that model's rate card. Requests your application makes on its own belong in the backend column too. The page says to include speculative lookups that were never used. An unused result does not erase the call.

3. The Realtime details are already inside the total

Realtime cost accrues when a Response is created, and it is charged on input and output tokens. Input transcription is the exception, below. The page says there is currently no separate charge for network bandwidth or for the connection itself. That sentence is explicitly current. A Response can be created by hand, or automatically when voice activity detection is on. VAD filters out empty input audio, so empty audio does not count as input tokens unless the client adds it to the conversation manually.

Each turn sends the whole conversation. The output is added to the server Conversation and becomes input on the next turn, so later turns cost more. Audio in a user message is estimated at 1 token per 100 ms. Audio in an assistant message is 1 token per 50 ms. Counts also include special tokens beyond the content, so they drift a little from a count of the words alone. The page's example is a user message with 10 text tokens of content that may be recorded as 12.

The page walks two turns. Turn one is 100 instruction tokens plus 20 audio tokens from the user, 120 input in all. The Response then produces an assistant message of 20 audio tokens and 10 text tokens. Turn two adds another user audio message, which the page sets at 25 audio tokens. The conversation now holds the original instructions, the first user message, the first assistant output, and the new user audio. The page gives this turn 110 text tokens and 64 audio tokens of input, plus another assistant output. Messages from the first turn are likely to be cached on the second, which lowers input cost. Caching is best-effort. It is not guaranteed.

The numbers for one Response are on response.done. The sample usage is total_tokens 253, input_tokens 132, output_tokens 121. Input details are text 119, audio 13, image 0, of which 64 are cached, and all 64 of those cached tokens are text. Output details are text 30 and audio 91. 132 plus 121 is 253. 119 plus 13 is 132. 30 plus 91 is 121. The cached 64 is already inside the 132. Audio is not a column added outside the total. Adding a detail on top of the total bills the same turn twice.

If input transcription is enabled, the Realtime API bills it separately. It uses a different model and a different rate card from the speech-to-speech model. Committed-turn transcription uses gpt-transcribe, and it starts after audio is written to the input buffer and the buffer is committed. Read usage on conversation.item.input_audio_transcription.completed. The fields follow the model: gpt-transcribe is duration, and the sample is type duration with seconds 3. A transcription model billed by tokens returns token counts instead. Transcription runs beside Response creation, so either event may arrive first. Order does not make them one bill. Streaming translation and streaming transcription sessions themselves are also outside the Response lifecycle. Estimate them with the duration rate, not with per-turn tokens.

4. The cache is not promised, and truncation cuts the front

Realtime prompt caching is automatic, and across many turns it can cut input cost sharply. It applies when this Response's input tokens match a previous Response. That match is best-effort, not a promise. The way to raise the hit rate is to keep the session history still. Removing or editing a stretch of the conversation breaks the cache back to the change, because the prefix no longer matches as far. Instructions and tool definitions sit at the start. Changing them mid-session lowers the hit rate on every later turn.

When the conversation passes the model's input limit, it is truncated. The oldest messages are dropped and are not sent as input for that Response. The page says a 32k context model with a 4,096 output cap can hold 28,224 tokens of context before truncation. A client can set a smaller window. token_limits.post_instructions caps input other than the instructions. At 1,000, items past that limit are not sent. The default retention_ratio is 1.0, which drops only what is over the limit. At 0.8, a truncation keeps 80 percent of the maximum and drops an extra 20 percent, so the next truncation comes later. Truncating on every turn keeps breaking the cache near the start, and the hit rate stays low. Truncation can also be disabled. Disabled, a conversation that is too long to create a Response returns an error, which fits a client that manages length itself.

The client can also delete items. conversation.item.delete removes an old message, and conversation.item.create can put a summary in its place. The summary is new input. It is not a free compression. A mini model is cheaper on the rate card. The page puts the tradeoff on instruction following and function calling. Run the prompt on the larger model first, then try the mini. Both choices change what later turns replay. Neither one is the switch that stops a Live session from billing silence.

5. A top-up does not shorten the seconds or the tokens

Reconcile by the interface this session actually used. On Live, record the final seconds, silence and backend wait included, do not sum usage snapshots, and do not add the 15-second setup on top of a running duration. Backend models and tools are another column. On Realtime, record each Response: audio, text and image are details, cached tokens are a subset of input, and a later turn includes the previous output. If transcription or translation is its own duration bill, leave it off that Response. Whether the cache hit depends on whether the prefix was edited or truncated.

Topping up the account happens before these columns are charged. Swapping a stablecoin on-chain for an asset that can pay the account does not close an open session at zero seconds, and it does not lift the audio detail out of the total. When that swap is the step you need, a no-signup, non-custodial exchange on AllSwap moves the asset. A completed swap only means the asset changed hands. The seconds and the tokens still follow what this call returned.