---
title: "GPT-Realtime-Whisper: Streaming Speech to Text Pricing"
description: "A senior lab's read on GPT-Realtime-Whisper, Whisper's streaming successor: $0.017 a minute against $0.0045 for batch, and when latency is worth it."
source: "https://www.kensink.com/models/whisper-speech/gpt-realtime-whisper/"
canonical: "https://www.kensink.com/models/whisper-speech/gpt-realtime-whisper/"
---
★ WHISPER'S SUCCESSOR · STREAMING OpenAI Model brief

OPENAI · STREAMING SPEECH TO TEXT · REALTIME API

# GPT-Realtime-Whisper. Whisper, rebuilt for live audio.

The original Whisper was built to transcribe a file after the fact, and every live captioning product since has been a workaround stacked on that assumption: chunk the audio, transcribe the chunk, stitch the seams, apologise for the latency. This model produces transcript deltas as the person is still speaking. It costs $0.017 a minute, which is nearly four times GPT-Transcribe, and the whole decision is whether anyone is waiting for the words.

Realtime API gpt-realtime-whisper Streaming STT Live captions

[Use it on your project →](https://www.kensink.com/contact) [OpenAI documentation ↗](https://openai.com/index/introducing-our-next-generation-audio-models/)

Released

May 2026

Model ID

gpt-realtime-whisper

Audio

$0.017 / minute

Per hour

About $1.02

Context

16K tokens

Max output

2K tokens

Modalities

Audio, text → text

Endpoint

Transcription sessions

\[TL;DR FOR CEO + CTO\]

## What to know.

-   01
    
    ### It is Whisper's job done in the right shape.
    
    Whisper was designed for post-recording transcription. Every live captioning product built on it has been chunking audio and stitching the seams, which is where the latency and the word errors at boundaries come from. This model streams natively, so that entire class of workaround goes away.
    
-   02
    
    ### The only question that matters is whether anyone is waiting.
    
    At $0.017 a minute it is 3.8 times the price of GPT-Transcribe at $0.0045. That premium buys latency and nothing else. If the transcript is read by a human or a model after the call ends, you are paying almost four times over for a property you do not use.
    
-   03
    
    ### About $1.02 an hour of audio.
    
    Cheap enough that transcription is rarely the line item that decides a product, and expensive enough to notice at scale: a thousand hours a month is roughly $1,020 against $270 on the batch model. Meter it per stream and know which of your streams actually need to be live.
    
-   04
    
    ### It has a sibling that is easier to tune.
    
    gpt-live-transcribe costs the same $0.017 a minute and exposes an explicit latency and accuracy dial, plus keyword hints, unstructured context, and multiple language hints. If you have domain vocabulary, product names, or code-switching, start there rather than here.
    
-   05
    
    ### Word error rate is no longer the interesting axis.
    
    On clean English the top providers now sit within a point or two of each other. ElevenLabs Scribe v2 led the Artificial Analysis leaderboard at 2.2% as of June 2026 against 5.2% for Deepgram Nova-3, and the competitive surface has moved to streaming latency, end-of-turn detection, multilingual depth, and cost per hour at scale.
    

\[THE NUMBERS\]

## Where it actually lands.

Speech to text does not have a single clean leaderboard the way coding does, and the honest comparison is on the axes teams actually feel. Word error rate figures are from Artificial Analysis as of June 2026; OpenAI does not publish a comparable AA-WER for these models, and we do not invent one.

| Capability | Realtime-Whisper | GPT-Transcribe | Scribe v2 Realtime | Deepgram Nova-3 |
| --- | --- | --- | --- | --- |
| 
List price per minute

Vendor pricing

the axis that decides most archive workloads

 | 

$0.017

 | 

$0.0045

 | 

tiered

 | 

tiered

 |
| 

Word error rate

Artificial Analysis AA-WER, Jun 2026

lower is better; OpenAI does not publish a comparable figure

 | 

not published

 | 

not published

 | 

2.2%

 | 

5.2%

 |
| 

Clean English, batch

Reported WER

lower is better

 | 

not published

 | 

not published

 | 

not published

 | 

5.26%

 |
| 

Streaming latency

Vendor claims

 | 

low-latency deltas

 | 

batch and streaming

 | 

sub-150ms

 | 

sub-300ms

 |
| 

End-of-turn detection

Built into the model

Deepgram Flux Multilingual reports median under 300ms

 | 

no

 | 

no

 | 

no

 | 

yes, on Flux

 |
| 

Language coverage

Vendor documentation

 | 

not specified

 | 

language hints

 | 

90+

 | 

multilingual on Flux

 |

Word error rate on clean English audio has plateaued, with the leading providers sitting within a point or two of each other, so a leaderboard position is a weak signal for a production decision. Accented speech, background noise, overlapping speakers, domain vocabulary, and telephony codecs are where the differences show up, and none of those are in a public benchmark. We build an eval set from the customer's own recordings before recommending a vendor, and we have changed our recommendation on that evidence more than once.

\[SOFTWARE DEVELOPMENT IMPACT\]

## What it changes for the team building with it.

The two comparisons a team actually makes: against the batch model that costs a quarter as much, and against the original Whisper that this replaces.

| Dimension | vs GPT-Transcribe | vs the original Whisper |
| --- | --- | --- |
| 
Cost per hour of audio

 | About $1.02 against $0.27. That is a 3.8x premium for latency alone. At a thousand hours a month it is the difference between roughly $1,020 and $270, which is worth an explicit decision rather than a default. | whisper-1 lists at $0.006 a minute, so the streaming model is roughly 2.8 times it. GPT-Transcribe undercuts even the legacy model while being stronger, which makes whisper-1 hard to justify on the API at all. |
| 

What you have to build

 | A persistent transcription session rather than a file upload. Different transport, different error handling, different reconnection logic. GPT-Transcribe serves both the file endpoint and a transcription session, so it is the easier one to start with. | This removes the chunk-and-stitch layer that every live Whisper deployment has had to write, along with the boundary word errors and the latency floor that came with it. If you maintain that layer today, deleting it is most of the migration. |
| 

Accuracy on hard audio

 | Streaming models see less context per decision than a batch model that has the whole file, so on genuinely hard audio a batch pass will usually read better. Where you need both, run the live stream for the interface and a batch pass afterwards for the record. | Both are stronger than whisper-1 on the API. Whisper's remaining advantage is that the weights are open, which matters when the audio cannot leave your infrastructure and matters not at all otherwise. |
| 

Tuning for your domain

 | GPT-Transcribe accepts keyword hints and unstructured context for domain terms, multilingual audio, and code-switching. So does gpt-live-transcribe at the same price as this model, which is why we usually reach for that one when vocabulary matters. | Prompting a transcription model with your product names and jargon is a genuinely new capability against the original Whisper, and it moves accuracy more than switching vendors does on domain-heavy audio. |

Transcription is step one, not the whole job. The value is in what happens next: diarisation, timestamps, formatting, and a clean handoff into summarisation, search, or extraction. We build the whole path and put evals on the part that actually carries risk.

\[WHAT IS NEW\]

## The features that ship with it.

01

### Streaming as the native design

The original Whisper transcribed a completed recording. This produces transcript deltas as the audio arrives, so live captions, meeting notes, and voice interfaces stop feeling like they are catching up with the speaker.

02

### The Realtime API left beta with this generation

Transcription sessions are now a supported production path rather than a beta you have to explain to a security reviewer. For regulated buyers that changes the conversation more than any accuracy number.

03

### Per-minute billing

Billed by the minute of audio at $0.017 rather than by token, so the cost of a stream is predictable before you ship it. gpt-realtime-translate and gpt-live-transcribe bill the same way, which makes a mixed pipeline easy to forecast.

04

### A tunable sibling at the same price

gpt-live-transcribe costs the same and exposes a latency and accuracy dial along with keyword hints, unstructured context, and multiple language hints. If you have domain vocabulary or code-switching, that is the better starting point.

05

### A much cheaper batch sibling

gpt-transcribe at $0.0045 a minute handles the file endpoint and a transcription session, and takes the same style of context and keyword hints. Most transcription workloads should land here, with streaming reserved for the ones a human is watching.

06

### A crowded field, which is good for you

ElevenLabs Scribe v2 Realtime leads reported word error rate at 2.2% with sub-150ms latency across more than 90 languages, and Deepgram Flux Multilingual puts end-of-turn detection inside the model at under 300ms median. Build behind an abstraction and keep the option to move.

\[WHAT CHANGES IN YOUR CODE\]

## The API surface, exactly.

Short list, because this model does one thing. The traps are all about which endpoint it serves and what it does not do for you.

Watch out

### Transcription sessions only

It serves v1/realtime/transcription\_sessions and nothing else. Not Chat Completions, not Responses, not the full realtime conversation session, and not the standard v1/audio/transcriptions file endpoint. If your code posts a file and expects a transcript back, that path needs GPT-Transcribe instead.

```
v1/realtime/transcription_sessions
```

Watch out

### It transcribes and nothing more

No diarisation, no speaker labels, no formatting, no summarisation. Those are your pipeline, and on most projects they are where the actual work is. Budget for the layer after the model, because a raw stream of words is rarely the deliverable anyone asked for.

```
output: text deltas
```

New

### Low-latency transcript deltas

Partial transcripts arrive as the audio does, which is what makes live captions and voice interfaces feel immediate. Design your UI to accept and revise partials rather than waiting for a final, or you throw away the property you paid for.

```
streaming: true
```

New

### Small context, and that is fine

16,000 token context and 2,000 max output. A transcription session is a rolling window over live audio rather than a document, so this is the right shape. It does mean the model is not holding the whole meeting in mind, which matters if you were hoping for a running summary from the same call.

```
context: 16,000 · max output: 2,000
```

If you need keyword hints, unstructured domain context, or explicit language hints, use gpt-live-transcribe at the same $0.017 per minute, or gpt-transcribe at $0.0045 for anything that does not have to be live. Those two carry the tuning surface that this model does not document.

\[THE SPEC\]

## Everything an integration depends on.

The limits, the endpoints, and the lines that decide whether this model fits your transport and your budget. Kept here so nobody has to reconstruct it from three vendor pages.

<table class="w-full min-w-[560px] border-collapse text-left"><tbody><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Model ID</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">gpt-realtime-whisper</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Context window</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">16,000 tokens</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Max output</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">2,000 tokens</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Knowledge cutoff</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">30 September 2024</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Input</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">Audio and text</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Output</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">Text</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Endpoint</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">v1/realtime/transcription_sessions only</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Not supported</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">Chat Completions, Responses, the full Realtime session, and the standard v1/audio/transcriptions file endpoint</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Streaming</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">Yes. Low-latency transcript deltas from live audio</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Pricing</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">$0.017 per minute of audio input</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Sibling</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">gpt-live-transcribe, same price, with an explicit latency and accuracy dial plus keyword and language hints</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[34%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Batch alternative</th><td class="p-4 align-top text-[14px] leading-relaxed text-ink-2">gpt-transcribe at $0.0045 per minute, which also serves the file endpoint</td></tr></tbody></table>

\[MIGRATION\]

## How we move a live integration.

Moving a live-captioning product off a chunked Whisper deployment. Step one is usually deleting more code than you add.

From chunked whisper-1

1.  01
    
    ### Build the eval set from your own audio first
    
    Pull fifty to a hundred real recordings that represent your hard cases: accents, background noise, overlapping speakers, domain vocabulary, telephony codecs. Public leaderboards will not tell you what you need to know, and this set is the only thing that will settle the vendor question.
    
2.  02
    
    ### Split your streams into live and not-live
    
    Go through every place you transcribe and ask whether a human is waiting on the words. Everything that is not live moves to gpt-transcribe at $0.0045 a minute. On most products this is the majority of the volume and pays for the migration on its own.
    
3.  03
    
    ### Replace the chunk-and-stitch layer with a session
    
    Open a transcription session and consume deltas instead of slicing audio, transcribing slices, and reconciling boundaries. Delete the stitching code, the boundary-correction heuristics, and the overlap buffer. This is the part where the codebase gets smaller.
    
4.  04
    
    ### Make the UI handle partials properly
    
    Streaming means text arrives provisional and gets revised. If the interface waits for a final transcript before rendering, you have paid a 3.8x premium for latency and then thrown it away. Render partials, mark them visually, and settle them in place.
    
5.  05
    
    ### Test gpt-live-transcribe against this model on your set
    
    Same price, with a latency and accuracy dial plus keyword and language hints. On domain-heavy or multilingual audio it frequently wins, and the hints move accuracy more than a vendor switch usually does.
    
6.  06
    
    ### Keep a batch pass where the record matters
    
    A streaming model decides with less context than a batch model that has the whole file. Where the transcript becomes a record rather than a caption, run the live stream for the interface and a cheap batch pass afterwards for the archive. At $0.0045 a minute that second pass is close to free.
    

\[PRICING\]

## What it costs to run.

Per minute of audio, at list. The comparison that decides most architectures is the first two rows.

<table class="w-full min-w-[560px] border-collapse text-left"><tbody><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[30%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">GPT-Realtime-Whisper</th><td class="w-[22%] p-4 align-top text-[15px] font-bold text-ink">$0.017 / min</td><td class="p-4 align-top text-[13px] leading-relaxed text-ink-4">About $1.02 per hour. Streaming transcription sessions.</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[30%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">GPT-Live-Transcribe</th><td class="w-[22%] p-4 align-top text-[15px] font-bold text-ink">$0.017 / min</td><td class="p-4 align-top text-[13px] leading-relaxed text-ink-4">Same price, with a latency and accuracy dial plus keyword and language hints.</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[30%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">GPT-Transcribe</th><td class="w-[22%] p-4 align-top text-[15px] font-bold text-ink">$0.0045 / min</td><td class="p-4 align-top text-[13px] leading-relaxed text-ink-4">About $0.27 per hour. File endpoint and transcription sessions. The default for anything not live.</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[30%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">GPT-4o Transcribe</th><td class="w-[22%] p-4 align-top text-[15px] font-bold text-ink">about $0.006 / min</td><td class="p-4 align-top text-[13px] leading-relaxed text-ink-4">Prior generation. $2.50 text in and $10 out on the token path.</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[30%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">Whisper v1</th><td class="w-[22%] p-4 align-top text-[15px] font-bold text-ink">$0.006 / min</td><td class="p-4 align-top text-[13px] leading-relaxed text-ink-4">Legacy. Undercut by GPT-Transcribe on both price and quality.</td></tr><tr class="border-b border-rule last:border-b-0"><th scope="row" class="w-[30%] bg-paper-3 p-4 align-top font-mono text-[10.5px] font-normal uppercase tracking-mono-wide text-ink-4">GPT-Realtime-Translate</th><td class="w-[22%] p-4 align-top text-[15px] font-bold text-ink">$0.034 / min</td><td class="p-4 align-top text-[13px] leading-relaxed text-ink-4">Speech to speech translation. 70+ input languages, 13 output.</td></tr></tbody></table>

Per-minute billing makes this one of the few parts of an AI stack you can forecast honestly before you build it. Take your monthly audio hours, split them into live and not-live, and price each at the right rate. The mistake we see most often is a single streaming pipeline handling everything, which turns a $270 line item into a $1,020 one for a latency property that only a fraction of the streams actually use.

\[RISK + GOVERNANCE\]

## What to watch.

### Recording consent is not one rule.

Consent requirements for recording and transcribing vary by jurisdiction, and some require all parties to agree rather than just one. That shapes your opening prompt, your consent flow, and what you may retain. Settle it before you build the pipeline, because retrofitting consent into a live product is genuinely painful.

### Transcripts are usually more sensitive than the audio.

Text is searchable, indexable, and easy to copy in bulk in a way audio is not. A transcript store inherits the sensitivity of every call that ever went through it, so it needs the retention policy, access controls, and deletion path you would give any other production data set. Decide the retention window before the first transcript exists.

### Word errors are not evenly distributed.

Accuracy is systematically worse on accented speech, non-native speakers, and code-switching, which means transcription quality tracks demographics. If a transcript drives a decision about a person, that is a fairness problem rather than a quality one, and it needs a human review path and an eval set that deliberately covers the speakers your headline metric hides.

\[OUR TAKE\]

## How we are using it.

01

### The right default is the batch model, not this one.

We start every transcription conversation by asking which streams a human is actually waiting on. The answer is usually a minority of them, and moving the rest to $0.0045 a minute frees the budget for the parts of the pipeline that carry real risk.

02

### Deleting the chunking layer is the real upgrade.

Every live Whisper deployment we have inherited had a homegrown chunk-and-stitch layer with boundary heuristics nobody wanted to touch. A native streaming model removes that code and the class of bugs that lived in it. That is worth more than a decimal place of word error rate.

03

### Test on your audio, not on a leaderboard.

Clean English word error rate has plateaued across the top providers, so published rankings barely separate them. Accents, noise, overlap, jargon, and telephony codecs do. We build an eval set from customer recordings first and let it pick the vendor.

04

### Keyword hints beat vendor switching on domain audio.

Feeding product names, drug names, ticker symbols, or internal jargon in as hints moves accuracy more than moving to the model at the top of a leaderboard. It is also cheaper and reversible, so we try it before we try anything else.

05

### The model is the easy part.

Diarisation, timestamps, formatting, redaction, and the handoff into summarisation or search is where the engineering is. We build that path and put the evals there, because that is where the failures reach a user.

\[METHODOLOGY · K-FRAMEWORK\]

## Integrated through the  
K-Framework.

Every model we integrate runs through the same operating system. Three pillars, sixteen layers, one Compound Growth Loop. The methodology that keeps AI work from rotting after the first ship.

[Read the K-Framework](https://www.kensink.com/k-framework)

01

### Foundations

Direct API integration with the model. No LangChain, no orchestration vendor, no agent framework built on quicksand. Typed contracts, the same way we wire up Postgres.

02

### Amplification

An eval suite built from your real tasks gates every prompt and model change. Quality is measured before it ships, not vibed in a demo.

03

### Judgment

Governance, audit, and oversight wired in from day one. Who called what, with which prompt version, at what cost. Your auditors get answers, not screenshots.

\[OBSERVABILITY\]

## Observability your team can read.

A model in production without observability is roulette. We instrument every integration so engineering and finance can see the same numbers, and so a regression at 3am surfaces before a customer opens a ticket.

Instrumented

### Cost per call

Tokens in, tokens out, dollars spent. Sliced by feature, tenant, and route. Budgets enforced where it matters.

Instrumented

### Latency p50 / p95 / p99

Real distributions, not averages. We know which routes are slow, and why.

Instrumented

### Eval pass rates

The same eval suite that gates a release runs continuously in production. A regression on real traffic surfaces fast.

Instrumented

### Prompt + completion logs

PII scrubbed at the proxy, shipped to your SIEM. Retention controls match your compliance window.

Dashboards your team owns, not ours. At handoff you get the queries, the alerts, and the runbook. We are not in the path to read your metrics.

\[COMMON QUESTIONS\]

## Questions we are getting asked.

Is this a replacement for Whisper?

For live audio, yes, and it removes the chunk-and-stitch workaround that live Whisper deployments have needed. For batch transcription the replacement is GPT-Transcribe at $0.0045 a minute, which is cheaper than whisper-1 and stronger. The one remaining reason to run Whisper is that its weights are open and can run on your own hardware.

When is the 3.8x premium over GPT-Transcribe worth paying?

When a human is waiting on the words: live captions, in-call assistance, voice interfaces, real-time note-taking that people watch. If the transcript is consumed after the fact by a person or a model, you are paying almost four times over for latency nobody experiences.

Does it do speaker diarisation and timestamps?

Not on its own. The model produces transcript text, and diarisation, speaker labels, timestamps, and formatting are your pipeline. Google took the other approach here: Gemini 3.5 Transcribe ships diarisation, word timestamps, and utterance-based language detection inside the model at $0.003 per minute. If those are on your requirements list, price both routes rather than assuming you have to build the layer.

Should we use this or gpt-live-transcribe?

They cost the same $0.017 a minute. gpt-live-transcribe documents an explicit latency and accuracy dial plus keyword hints, unstructured context, and multiple language hints, so if you have domain vocabulary, multilingual audio, or code-switching, start there. Run both against your own recordings and let the numbers decide.

Which vendor is most accurate?

On the Artificial Analysis leaderboard as of June 2026, ElevenLabs Scribe v2 led at 2.2% word error rate against 5.2% for Deepgram Nova-3, and OpenAI does not publish a comparable figure for these models. That ranking is weaker evidence than it looks: clean English accuracy has plateaued and the differences that matter show up on accents, noise, and jargon. Test on your audio.

How do we keep transcription cost under control at scale?

Three levers, in order of impact. Route anything not live to the batch model at a quarter of the price. Do not transcribe audio nobody will read, which is more common than teams expect. And meter per stream rather than in aggregate, so a single runaway pipeline shows up as a line rather than as a surprise at the end of the month.

Share[](https://twitter.com/intent/tweet?url=https%3A%2F%2Fwww.kensink.com%2Fmodels%2Fwhisper-speech%2Fgpt-realtime-whisper%2F&text=GPT-Realtime-Whisper%20brief)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fwww.kensink.com%2Fmodels%2Fwhisper-speech%2Fgpt-realtime-whisper%2F)

[View .md](https://www.kensink.com/models/whisper-speech/gpt-realtime-whisper.md)

\[RELATED\]

## Worth a look next.

[

MODEL

GPT-Transcribe (the cheaper default)

Read more

](https://www.kensink.com/models/whisper-speech/gpt-transcribe/)[

MODEL

GPT-Realtime-2.1 (voice agents)

Read more

](https://www.kensink.com/models/whisper-speech/gpt-realtime-2-1/)[

MODEL FAMILY

Voice & speech (overview)

Read more

](https://www.kensink.com/models/whisper-speech/)

DIRECT INTEGRATION · NO FRAMEWORK

## Want GPT-Realtime-Whisper  
in your product?

Eval suite at handoff, full source ownership. We integrate against the model API the same way we integrate against Postgres, and route by task at runtime. Sized to your scope.

[Start a conversation →](https://www.kensink.com/contact) [All Voice & Speech models](https://www.kensink.com/models/whisper-speech)
