Blog · 2026-08-07 · Vynaris Team

Self-hosted voice vs gpt-realtime-2.1-mini: the $0.015/minute break-even

At 50% utilization, one L4 costs $0.019 per call-minute; ten packed calls cost $0.0019 each, if realtime capacity and quality hold.

At 50% scheduled utilization, one NVIDIA L4 costs $0.019 per occupied call-minute. That is 27% above the $0.015 audio floor for gpt-realtime-2.1-mini. Pack ten concurrent calls onto that GPU and rent falls to $0.0019 each, 87% below the API floor. The win exists only if measured capacity, latency, and quality survive the packing.

Prices verified 2026-08-07.

TL;DR

OpenAI bills realtime user audio at one token per 100 milliseconds and assistant audio at one token per 50 milliseconds. A 50/50 call-minute produces 300 input and 600 output audio tokens.
gpt-realtime-2.1-mini costs $10/1M audio input and $20/1M audio output. Its audio-only floor is $0.015 per call-minute. gpt-realtime-2.1 costs $32/$64 and lands at $0.048.
At 50% utilization, an L4 at $0.57/hour costs $0.019, $0.0019, and $0.00019 per call-minute at 1, 10, and 100 packed calls. An A100 80GB at $2.10/hour costs $0.070, $0.007, and $0.0007.
Those self-host rows are GPU-only capacity bounds. They are valid only if one GPU sustains the stated concurrency at production latency. The public voice-pipeline post does not publish that benchmark.
Self-hosting is not $0. API pricing is not the whole API bill either: text context, optional transcription, tools, and growing conversation history sit above the audio floor.

The verdict table

Option                        Public rate                        Cost/call-minute    Verdict at 50% utilization
----------------------------  ---------------------------------  ------------------  ----------------------------------------------------------------------------------
gpt-realtime-2.1-mini         $10/1M audio in, $20/1M audio out  $0.015 audio floor  Buy when average packed concurrency stays below 2 L4 calls or 5 A100 calls
gpt-realtime-2.1              $32/1M audio in, $64/1M audio out  $0.048 audio floor  Higher instruction-following tier; one half-used L4 is already cheaper on GPU rent
NVIDIA L4, 1 packed call      $0.57/GPU-hour                     $0.019 GPU-only     27% above mini, 60% below full model
NVIDIA L4, 10 packed calls    $0.57/GPU-hour                     $0.0019 GPU-only    87% below mini if measured capacity clears 10
NVIDIA A100, 1 packed call    $2.10/GPU-hour                     $0.070 GPU-only     4.67x mini and 46% above full model
NVIDIA A100, 10 packed calls  $2.10/GPU-hour                     $0.007 GPU-only     53% below mini if measured capacity clears 10

The comparison is not a quality claim. A self-hosted pipeline and an OpenAI speech-to-speech model can differ in reasoning, turn detection, tool use, voice quality, and failure behavior. Price them only after both clear the same acceptance test.

Build the API floor from audio tokens

OpenAI's Realtime cost guide gives the conversion that per-token price tables omit:

User audio: one audio token per 100 milliseconds, or 10 tokens/second. That duration conversion turns the rate card into a cost per token.
Assistant audio: one token per 50 milliseconds, or 20 tokens/second.

For one shared call-minute, we assume the caller speaks for 30 seconds and the agent speaks for 30. Silence filtered by voice activity detection is not counted as user input audio. A streaming response still bills the tokens it emits.

input audio  = 30 seconds x 10 tokens/second = 300 tokens
output audio = 30 seconds x 20 tokens/second = 600 tokens

Now apply the live input/output token pricing.

Model                  Audio input             Audio output            Audio floor/call-min
---------------------  ----------------------  ----------------------  --------------------
gpt-realtime-2.1-mini  300 x $10/1M = $0.0030  600 x $20/1M = $0.0120  $0.0150
gpt-realtime-2.1       300 x $32/1M = $0.0096  600 x $64/1M = $0.0384  $0.0480

This is a floor, not a forecast invoice. Conversational Realtime sends prior conversation items with later responses. Text instructions, tools, and transcript tokens use separate text rates. Input transcription, if enabled, uses another model and rate card. OpenAI recommends measuring a representative session because later turns can cost more.

The 50/50 talk split is editable. If the caller speaks longer, cheaper input audio replaces pricier output audio. The exact bill moves down. If the agent dominates the minute, it moves up.

Build the self-hosted line from GPU rent

The viral pipeline post describes local GPU execution as free. The software may be open source, but compute remains rented or owned. E2E Networks lists these on-demand rates:

GPU          Memory  Hourly rate  Taxes
-----------  ------  -----------  --------
NVIDIA L4    24GB    $0.57        Excluded
NVIDIA A100  80GB    $2.10        Excluded

For a GPU that stays provisioned while only a fraction of scheduled time carries paid calls:

GPU cost/call-minute = GPU dollars/hour
                     / (60 x average concurrent calls x scheduled utilization)

At 50% utilization, the denominator contains 30 useful minutes per provisioned hour.

GPU               1 concurrent  10 concurrent  100 concurrent
----------------  ------------  -------------  --------------
NVIDIA L4 24GB    $0.01900      $0.00190       $0.00019
NVIDIA A100 80GB  $0.07000      $0.00700       $0.00070

The 100-call column is not a throughput claim. It is the financial result if one GPU sustains 100 simultaneous calls. That condition is the entire capacity test. If the stack needs ten GPUs for 100 calls, use ten times the hourly numerator and the per-call cost returns to the ten-calls-per-GPU row.

Log-scale chart comparing L4 and A100 GPU-only cost per occupied call-minute from 1 to 100 packed concurrent calls at 50% utilization, against the $0.015 gpt-realtime-2.1-mini and $0.048 gpt-realtime-2.1 audio floors. — GPU-only self-hosted voice cost versus OpenAI Realtime audio floors. Prices verified 2026-08-07. Every GPU point requires measured capacity at realtime latency.

Use the calculator to replace the 300/600 audio-token shape with a measured session before approving a build-vs-buy decision.

Break-even concurrency at 50% utilization

Solve the GPU equation for average concurrent calls:

break-even calls = GPU dollars/hour
                 / (60 x utilization x API dollars/call-minute)

GPU               vs mini $0.015  Integer capacity needed  vs full $0.048  Integer capacity needed
----------------  --------------  -----------------------  --------------  -----------------------
NVIDIA L4 24GB    1.27 calls      2                        0.40 calls      1
NVIDIA A100 80GB  4.67 calls      5                        1.46 calls      2

At this utilization, a two-call L4 beats the mini audio floor on GPU rent. An A100 needs five average calls. Against the full model, one L4 or two A100 calls clear the raw compute line.

Utilization moves the threshold before concurrency does. At one active call, an L4 costs $0.038 at 25%, $0.019 at 50%, and $0.01188 at 80%. The same A100 costs $0.14, $0.07, and $0.04375. A low-traffic voice product can lose money on idle GPU time even when its model is efficient.

This is the same fixed-capacity trap in our GLM 5.2 self-hosting break-even analysis. Voice adds a stricter throughput vs. latency tradeoff: capacity counts only when the reply stays inside a natural turn.

Where the simple model is wrong

The spreadsheet excludes costs that appear in production.

Capacity at acceptable latency. Measure simultaneous calls, time to first audio, interruption handling, and p95 turn delay. Offline audio throughput is not a realtime benchmark.
Redundancy. One hot spare doubles GPU rent when the spare is idle. Active-active capacity can reduce that waste, but only if traffic reaches both replicas.
Network and orchestration. Load balancers, egress, signaling, logs, and deployment compute remain separate.
Engineering. Quantization, drivers, autoscaling, upgrades, and incident response need owners. The API line includes that work in its price.
Conversation memory. OpenAI applies automatic prompt caching when prior tokens match. Editing or truncating history can break the cache. A local stack needs its own memory policy.
Quality parity. A cheaper pipeline is not cheaper per resolved call if weak tool use or turn detection sends more calls to humans.

Run the capacity test with recorded two-way calls, not synthetic one-way audio. Keep the same prompt, tools, codec, turn detector, interruption pattern, and quality rubric on both systems. Increase simultaneous sessions until either tail delay or task success crosses the acceptance limit. The last passing level is usable capacity. Price the failed runs as test expense, then use only the passing level in the concurrency denominator. Anything else turns offline throughput into fictional revenue capacity.

The existing modular voice-agent playbook prices separate speech-to-text, text LLM, and text-to-speech stages. This analysis prices an end-to-end speech-to-speech API against fixed GPU capacity. Mixing the two models would double-count components.

Where routing changes the decision

There are two routing layers. The first chooses API versus self-hosted capacity. Send steady, latency-tolerant traffic to a measured local pool. Keep API capacity for bursts, regions without a warm GPU, and failure recovery. That avoids renting the peak all day.

The second layer chooses model quality. OpenAI's cost guide says the mini model is cheaper, with a tradeoff in instruction-following and function calling. Start with the larger model to define the quality bar, then test mini on the same calls. Route difficult turns only when a cheap confidence signal predicts them. Otherwise, the first pass plus escalation pays twice.

Honest tradeoff: the API can be cheaper even above sticker break-even

Self-hosting wins the GPU equation at surprisingly low packed concurrency. That does not settle total cost of ownership. A solo team with spiky calls can spend more engineering a pool than it saves in tokens. The managed API also absorbs model updates, autoscaling, regional capacity, and failure recovery.

Self-host when average concurrency is durable, privacy or model control has real value, and a production load test proves capacity. Use the API when traffic is thin, bursty, or operationally inconvenient. A $0.57 GPU sitting idle is not free. It is a meter with worse observability.

Sources

OpenAI API pricing, captured 2026-08-07: gpt-realtime-2.1 audio at $32/$64 per 1M input/output tokens and mini at $10/$20.
OpenAI Realtime cost guide, captured 2026-08-07: user audio at one token/100ms, assistant audio at one token/50ms, conversation billing, caching, and transcription caveats.
E2E Networks GPU pricing, captured 2026-08-07: NVIDIA L4 at $0.57/hour and A100 80GB at $2.10/hour, taxes excluded.
Public voice-pipeline post, captured 2026-08-07: 1,877 likes, 251 reposts, and 43 replies; used as the demand signal, not a throughput source.

All workload values are disclosed assumptions or primary-source rates. No Vynaris traffic, customer, or routing data is used.