OpenAI Realtime API Pricing: The Real Cost Per Minute

Here's the trap. You test an OpenAI Realtime API voice agent for an afternoon, the dashboard says you spent forty cents, and you ship it. Two weeks later finance forwards you a bill with a comma in it you didn't expect. The Realtime API is priced in audio tokens, not minutes, and those tokens pile up in ways the pricing page doesn't spell out. We've shipped voice agents on this API for clients in healthcare and consumer apps, and the gap between the demo cost and the production cost is where most teams get hurt.

This is OpenAI Realtime API pricing with the reasoning attached, current to July 2026. We'll show the token math out loud, the per-minute numbers you can actually budget against, why the bill grows during long calls, and when a cheaper cascade or a managed platform beats it. For how to wire the thing up across transports, that's a separate guide (linked below). Here we answer one question: what does this really cost?

Why Fora Soft wrote this pricing guide

We're a software team that has built real-time and AI products since 2005: 625+ projects, about 50 engineers, and a specialty in voice, video, and the messy parts where they meet. When a client asks us to put a voice agent on the phone, the second question after “can you build it” is always “what will it cost to run.” So we keep a spreadsheet, and this article is that spreadsheet with the reasoning attached.

Some of what we know comes from products, not slides. BlaBlaPlay, an anonymous voice social app we built, runs OpenAI models and Whisper across thousands of users, so we've watched audio-token bills at scale rather than in a playground. And we've shipped an AI appointment-booking voice agent (client under NDA) that replaced a manual scheduling desk end to end. Both taught us the same lesson: the headline rate tells you almost nothing until you multiply it by how people actually talk.

Every number below is dated and sourced. OpenAI's rates come straight from their pricing page and Realtime cost guide, captured on 2026-07-13; vendor rates come from vendor pages with the date we pulled them. Where we estimate, we show the arithmetic so you can swap in your own assumptions. For the engineering fundamentals under all this, our AI-for-video-engineering hub goes deeper; if you'd rather we just model your specific agent, that's what our AI integration team does.

The headline price, in one table

OpenAI Realtime API pricing has one wrinkle that trips everyone up: it's billed per token, not per minute, and audio, text, and images each have their own rate. Speech-to-speech agents live and die by the two audio rows. Here's the full rate card for the current models as of July 2026, straight from OpenAI's pricing page.

Source: OpenAI pricing page, captured 2026-07-13. Image input on the flagship is $5.00 / 1M; cached text input is $0.40 / 1M.

Two things jump out. First, output audio costs twice as much as input audio. The assistant's voice is your priciest line item. Second, cached audio input is 80 times cheaper than fresh audio input ($0.40 versus $32). That single gap decides whether a long conversation costs pennies or dollars. We'll come back to it.

Before we turn tokens into dollars, look at what a single billed session is actually made of. Figure 1 breaks it into the pieces that hit your invoice.

Figure 1. What a single Realtime session bills: fresh input audio, output audio, the cached conversation prefix, text and tool tokens, and the optional transcription add-on.

How the Realtime API actually bills you: tokens, not minutes

The Realtime API converts audio into tokens at a fixed rate, and that rate is the key to every estimate on this page. OpenAI documents it plainly: audio in user messages is one token per 100 ms, and audio in assistant messages is one token per 50 ms.

Translate that to the units you think in. One minute of the user speaking is 600 tokens (10 tokens a second). One minute of the assistant speaking is 1,200 tokens (20 tokens a second) — the model's own voice is encoded at twice the resolution, so it costs twice the tokens before you even look at the higher output rate. A token is not a word here; it's a slice of sound. That's why “cost per minute” is a derived number, not a price OpenAI publishes.

One honest caveat: token counts include a few control tokens per message, so a turn that looks like 10 tokens might bill as 12. It's a rounding effect, not a trap, but it means your real numbers run a hair above the clean math. Now let's do the clean math.

What that costs per minute

Start with the number you can't avoid: the assistant's voice. On the flagship, one minute of the bot talking is 1,200 tokens × $64 / 1,000,000 = $0.077. On the mini it's 1,200 × $20 / 1M = $0.024. A minute of the user talking (input) adds 600 × $32 / 1M = $0.019 on the flagship, or $0.006 on the mini.

Real calls aren't one person talking non-stop. In a typical support minute the user speaks maybe 30 seconds and the bot answers for 25, with the rest silence and turn-taking. That first pass costs, on the flagship: 300 input tokens ($0.0096) plus 500 output tokens ($0.032), so about $0.042 per minute of conversation — before we account for the part that hurts. Figure 2 lays the arithmetic out so you can plug in your own talk-time split.

Figure 2. The per-minute math for a minute of assistant speech, flagship versus mini — formula, substitution, result.

So why do teams see $0.20 or $0.40 a minute in production when the physics says four cents? Because that $0.042 is the cost of the audio once. The Realtime API re-reads the whole conversation on every turn, and that replay is where the money goes.

The hidden cost: context grows every turn

Every time the model responds, it processes the entire conversation so far as input. The user's earlier audio, the assistant's own earlier audio, the system prompt, the tool definitions — all of it is re-sent and re-billed as input tokens on each turn. Early in a call that's cheap. By turn fifteen, the model is re-reading minutes of accumulated audio just to say one more sentence.

Worked example: one mid-call turn. Say you're twelve turns into a support call. The history holds 90 seconds of user audio (900 tokens), 90 seconds of assistant audio (1,800 tokens), and a 1,000-token system-and-tools prompt. The user now says one 6-second sentence (60 tokens in); the bot replies for 5 seconds (100 tokens out). On the flagship, with no caching:

• Input this turn: (900 + 1,800 + 60) audio × $32/1M + 1,000 text × $4/1M = $0.0883 + $0.0040 = $0.0923.

• Output this turn: 100 × $64/1M = $0.0064.

• Turn total: about $0.099. Ten cents for a single sentence, because the model paid to re-read the whole call to produce it.

Left unmanaged, this compounds. HackerNoon instrumented 4,000 production sessions in mid-2026 and clocked a runaway session at 480,000 tokens and $2.05 for a single call. The fix isn't magic — it's caching, and it's the difference between the number above and one cent.

Prompt caching: the 80× lever that decides your bill

The Realtime API caches automatically. When the input tokens of a new response match tokens from a previous response in the same session, the repeated part bills at the cached rate: $0.40 per 1M audio input instead of $32, and $0.40 per 1M text input instead of $4. OpenAI calls it best-effort and doesn't guarantee a hit, but in a normal session the growing prefix is exactly the kind of repeated content that caches well.

Same turn, now cached. The 2,700 tokens of replayed audio and the 1,000-token prompt hit the cache; only the new 60-token sentence is fresh:

• Cached input: (2,700 audio + 1,000 text) × $0.40/1M = $0.0015.

• Fresh input: 60 × $32/1M = $0.0019.

• Output: 100 × $64/1M = $0.0064. Turn total: about $0.0098 — roughly a tenth of the uncached turn.

Put the two examples together and you get a defensible budget. A cached five-minute flagship call (assistant talking about 90 seconds of it) lands around $0.18, or roughly $0.035 to $0.09 per minute depending on how much the bot talks. The same call with caching broken can run $0.18 to $0.46 a minute. Same API, same model, 5× spread, decided entirely by how you manage context.

How much cheaper it has gotten since 2024

If you priced a voice agent in late 2024 and walked away, re-price it. Realtime audio has fallen hard. At the October 2024 beta, gpt-4o-realtime-preview cost $100 per 1M audio input and $200 output. The December 2024 snapshot cut that to $40 / $80 and added cached input at $2.50. At general availability in August 2025, gpt-realtime dropped another 20% to $32 / $64 with cached input at $0.40. The 2.1 generation held those audio rates.

Sources: OpenAI launch and GA announcements plus the current pricing page, captured 2026-07-13.

One counter-trend worth knowing: text output rose from $16 to $24 per 1M across gpt-realtime to 2.1, because 2.1 added reasoning tokens. Audio stayed flat. If your agent leans on tool calls and text reasoning rather than long spoken answers, that shift matters; for a mostly-spoken bot it barely registers. The pattern to plan around: audio keeps getting cheaper, so lock your architecture, not last year's price.

gpt-realtime-2.1 versus 2.1-mini: when the mini is enough

The mini is roughly a third of the flagship's price: $10 / $20 audio versus $32 / $64. For a lot of production agents, it's also enough. Booking a table, checking an order, routing a call, reading back an address — these are narrow tasks where the mini's speech quality and instruction-following hold up fine, and the 3× saving compounds across every minute of every call.

The flagship earns its price when the conversation is open-ended: multi-step reasoning, nuanced tone, tricky interruptions, or a knowledge base the bot has to reason over live. We default clients to the mini and reserve the flagship for the turns that actually need it. Some teams even route hard turns to the flagship and keep the rest on the mini. Test both on your own scripts before you decide; the price gap is big enough that “the mini is fine” is worth ten minutes of listening.

Realtime API versus a STT + LLM + TTS cascade

The Realtime API bundles speech-in, reasoning, and speech-out into one model. The older approach chains three services: speech-to-text, then a text LLM, then text-to-speech. On pure price, the cascade can win — but it buys that with latency and engineering. Here's the crossover, with vendor rates captured 2026-07-13.

A cascade minute, roughly: Deepgram Nova-3 streaming STT at $0.0077/min of audio, a cheap LLM like gpt-5.4-mini ($0.75 in / $4.50 out per 1M) at well under a cent for a few short turns, and ElevenLabs Flash TTS at $0.05 per 1,000 characters. A 25-second answer is roughly 400 characters, so about $0.02. Add it up and a cascade minute is around $0.02–$0.03, cheaper than the flagship Realtime and comparable to the mini. Swap ElevenLabs for Deepgram Aura-2 TTS at $0.030/1K and it drops further.

So why does anyone pay more for Realtime? Latency and simplicity. A cascade runs three network hops in series (speech-to-text, then the LLM, then text-to-speech) and each adds delay, so you're fighting 300 to 800 ms of extra round-trip plus the engineering to handle voice-activity detection, endpointing, and barge-in yourself. The Realtime API does that natively and answers in a few hundred milliseconds. Figure 3 shows the two paths side by side.

Figure 3. Realtime API (one model, ~300 ms) versus a STT + LLM + TTS cascade (three serial hops, ~600–1,100 ms) — cheaper per minute, slower and more to build.

Managed platforms versus building your own

You don't have to call OpenAI directly. Platforms like Vapi and Retell AI wrap the model, telephony, and orchestration into one SDK and charge a per-minute platform fee on top of the model cost. That fee buys you speed to launch; at scale it's also the thing you're paying to avoid.

The going rates, captured 2026-07-13: Vapi charges $0.05/min platform fee on top of your STT, LLM, and TTS (bring your own keys and those pass through at cost). Retell AI runs $0.07–$0.31/min all-in depending on the stack, with its own voice-infrastructure fee at $0.055/min. ElevenLabs Agents is $0.08/min for their speech engine, with the LLM and telephony billed separately. Deepgram's Voice Agent API is $0.075/min all-in. The pattern: a platform fee of roughly $0.05–$0.08/min sits above whatever the underlying model costs.

That fee is trivial at pilot scale and painful at production scale. At 184,800 minutes a month (we'll derive that number shortly), a $0.05/min platform fee alone is $9,240 a month, about $111,000 a year, before the model cost. That's the budget that funds a custom build. It's the same build-versus-buy line we walk through in our LiveKit versus Agora cost analysis, just applied to voice agents.

The five options compared, side by side

One table to hold it all. Per-minute figures assume a typical conversational agent with caching working; managed rows include the platform fee but not the passthrough model cost unless noted.

Vendor fees from Vapi, Retell, Deepgram, ElevenLabs, and OpenAI pricing pages, captured 2026-07-13. Telephony (Twilio ~$0.0085–$0.014/min) is extra on any phone-based option.

Mini-case: an AI appointment-booking voice agent

A healthcare client (under NDA) came to us with a manual scheduling desk: staff answering calls, verifying patients, reading out open slots, and booking by hand. They wanted a voice agent to take the routine calls end to end (verify the caller, check whether they were new or returning, present provider availability, book, confirm, and schedule reminders) without a human in the loop for the common path.

The cost question decided the architecture. These calls are scoped and repetitive, so we ran them on the mini tier rather than the flagship, kept the system prompt and provider list stable at the head of the context so caching held, and let only the live slot data change per turn. That combination put the model cost in the low single-digit cents per minute rather than the $0.20-plus a naive flagship build would have produced. Telephony and the transcription add-on were the next line items, not the model.

The outcome was a fully automated booking flow that handles the routine volume and hands the edge cases to staff. It's the same pattern we describe in our production voice-agent guide, where the architecture and compliance live. Want us to model the per-minute cost of your agent the same way? Grab a 30-minute call and bring a call flow.

What it costs at scale: concurrency and monthly math

Per-minute pricing hides the number your CFO cares about: the monthly bill. That's driven by concurrency — how many calls run at once — times how long your lines are busy. The formula is plain: monthly minutes = concurrent lines × hours/day × working days × 60 × occupancy (the share of time a line is on a call).

Take a mid-size support line: 25 concurrent agents, 8 hours a day, 22 working days, 70% busy. That's 25 × 8 × 22 × 60 × 0.7 = 184,800 minutes a month. Now price it: on the flagship at $0.08/min that's about $14,800/month; on the mini at $0.04/min, about $7,400; through Vapi at roughly $0.13/min all-in, about $24,000. Figure 4 plots how that scales with concurrency.

Figure 4. Monthly cost versus concurrent lines for flagship, mini, and a managed platform — the 25-line operating point marked.

Two planning notes. OpenAI enforces concurrent-session limits by usage tier, so a large fleet needs headroom on your account before launch — check your tier's cap, don't assume infinite lines. And occupancy is the lever people forget: dropping from 70% to 40% busy cuts the bill by nearly half without touching the per-minute rate. Model the monthly number, not the minute, when you decide build versus buy.

Line items people forget

1. Input transcription. If you want text transcripts of the user (for logs, analytics, or compliance), the Realtime API runs a separate transcription model on top of the speech-to-speech tokens. gpt-realtime-whisper is $0.017/min; gpt-4o-transcribe is about $0.006/min. Small per call, real across a fleet.

2. Telephony. A phone agent needs a carrier. Twilio's SIP interface is $0.0040/min, inbound local numbers about $0.0085/min, outbound US about $0.014/min. The Realtime API itself charges nothing for the WebRTC, WebSocket, or SIP connection — but the phone network does.

3. Silence and dead air. You pay for the assistant's audio whether or not the user is listening, and long generated pauses or filler still bill as output tokens. Tight prompts that keep the bot concise cut cost twice: fewer output tokens now and a smaller cached prefix later.

4. Tool calls and text reasoning. Every function definition and tool result sits in the context and bills as text on each turn, and 2.1's reasoning tokens count as output. A bot with twelve tools and verbose results carries a heavier per-turn tax than one with three lean ones.

Seven ways to cut a Realtime API bill

1. Keep the prompt head stable. Put your fixed system prompt and tool definitions first and dynamic data last, so the cache prefix survives the whole call. This is the single biggest lever — it's the $0.099-to-$0.010 turn from earlier.

2. Default to the mini. Start every agent on gpt-realtime-2.1-mini and only promote the turns that genuinely need the flagship. Most don't.

3. Prune old audio. Trim or summarize turns the model no longer needs so the replayed context stops growing. A rolling window beats an infinite transcript.

4. Make the bot concise. Every second of assistant speech is 20 output tokens. Prompts that reward short answers cut your most expensive line item directly.

5. Cap the call. Set a max session length and turn count. Runaway sessions are where the $2 calls come from; a hard limit turns a tail risk into a known ceiling.

6. Trim tools. Fewer, leaner function definitions and shorter tool results mean a lighter per-turn text tax. Drop tools the agent never calls.

7. Skip transcription you don't use. Turn off input transcription unless a log or compliance rule needs it. It's a separate meter running the whole call.

A pricing decision in five questions

1. How much will the bot actually talk? Output audio is your floor at $0.077/min (flagship) of speech. If answers are long, the model choice matters more than anything else. If they're short, you have room.

2. How long are your calls? Short, transactional calls barely feel context growth. Ten-minute conversations live or die by caching — if you can't keep the prefix stable, budget for the uncached range.

3. Does the task need the flagship? Be honest. Most booking, routing, and FAQ bots run fine on the mini at a third of the price. Reserve the flagship for reasoning-heavy or high-stakes calls.

4. What's your monthly volume? Under ~50,000 minutes, a managed platform's fee is cheaper than building. Past ~150,000, the fee you'd avoid funds a custom build in months.

5. Do you need latency or price? If natural, low-latency conversation is the product, Realtime earns its rate. If price is the hard limit and a beat of delay is fine, a cascade wins. Answer these five and the bill picks itself — or have us answer them with you.

When NOT to use the Realtime API on cost grounds

The Realtime API is the wrong tool when latency doesn't matter. If you're generating a voicemail, a podcast intro, or any audio nobody is waiting on live, batch text-to-speech is far cheaper — you're paying Realtime's premium for real-time speech you don't need. Render the text with a cheap LLM and voice it with standard TTS.

It's also the wrong tool at very high volume with very simple flows. A press-1-for-billing menu doesn't need a reasoning model on every call; a rules-based IVR with a little TTS costs a fraction. And if your calls routinely run long and open-ended and you can't control the context, the uncached cost can climb past what a human agent costs in some markets — at which point the honest answer is a hybrid, not a pure bot.

We'll say this plainly because it builds trust: if your use case is asynchronous or trivially scripted, don't pay for Realtime. Use it where a natural, interruptible, low-latency conversation is the actual product. That's the line we hold with our own clients.

FAQ

How much does the OpenAI Realtime API cost per minute?

There's no per-minute price; it's billed per audio token. Derived from the July 2026 rates, a typical agent runs about $0.06–$0.11/min on gpt-realtime-2.1 and $0.02–$0.05/min on the mini once prompt caching is working. Without caching, long calls can reach $0.18–$0.46/min.

Is the Realtime API priced per token or per minute?

Per token. Audio is converted at one token per 100 ms for the user and one token per 50 ms for the assistant, so a minute of user speech is 600 tokens and a minute of assistant speech is 1,200 tokens. You multiply those by the per-1M rates to get dollars.

How much cheaper is gpt-realtime-2.1-mini than the flagship?

About a third of the price: $10/$20 per 1M audio in/out versus $32/$64 on the flagship (July 2026). For scoped tasks — booking, lookups, routing, FAQs — the mini is usually enough, and the saving compounds across every minute.

Does prompt caching really cut the bill, and by how much?

Yes, and it's the biggest lever. Cached audio input bills at $0.40 per 1M instead of $32 — 80 times cheaper. On a late-call turn that's the difference between about $0.099 and $0.010. Caching is automatic but best-effort, so keep the head of your prompt stable to keep the hit rate high.

Why does my Realtime API bill grow during long calls?

Because the model re-reads the whole conversation as input on every turn. Without caching or pruning, the replayed audio grows each turn and the per-turn cost climbs with it — instrumented sessions have hit 480,000 tokens and $2 on a single runaway call. Caching plus a rolling context window fixes it.

Is the Realtime API cheaper than a STT + LLM + TTS cascade?

Usually no on raw price — a cascade runs about $0.02–$0.04/min, comparable to the Realtime mini and cheaper than the flagship. But the cascade adds 300–800 ms of serial latency and more engineering (VAD, endpointing, barge-in). You pay Realtime for lower latency and a simpler stack.

Does WebRTC, WebSocket, or SIP change the price?

No. All three hit the same endpoint and bill identically on tokens, and OpenAI charges nothing for the connection or bandwidth. Your transport choice affects latency and integration effort, not the token bill — though a phone agent still pays a carrier like Twilio separately.

What does a voice agent cost at 100,000 minutes a month?

At the mini's ~$0.04/min, roughly $4,000/month in model cost; at the flagship's ~$0.08/min, about $8,000. A managed platform adds its $0.05–$0.08/min fee on top — another $5,000–$8,000 — which is why volumes this size start to favor a custom build.

What to read next

Ready to model your real bill?

OpenAI Realtime API pricing starts simple: $32 and $64 per 1M audio tokens on the flagship, a third of that on the mini. The bill you actually get depends on three things: how much the bot talks, whether caching holds across the call, and whether you're at a volume where a managed platform's fee outgrows a custom build. Get those right and a production voice agent runs $0.02–$0.11 a minute; get them wrong and the same agent quietly triples.

The math on this page is yours to reuse. Swap in your talk-time, your call length, your volume. But if you'd rather hand it to a team that has shipped these and watched the invoices, that's us. We'll model your agent's per-minute cost, tell you flagship-or-mini and buy-or-build, and if it's worth it, build the cheaper version.