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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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_sessionsNo 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 deltasPartial 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: true16,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,000If 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 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.
| Model ID | gpt-realtime-whisper |
|---|---|
| Context window | 16,000 tokens |
| Max output | 2,000 tokens |
| Knowledge cutoff | 30 September 2024 |
| Input | Audio and text |
| Output | Text |
| Endpoint | v1/realtime/transcription_sessions only |
| Not supported | Chat Completions, Responses, the full Realtime session, and the standard v1/audio/transcriptions file endpoint |
| Streaming | Yes. Low-latency transcript deltas from live audio |
| Pricing | $0.017 per minute of audio input |
| Sibling | gpt-live-transcribe, same price, with an explicit latency and accuracy dial plus keyword and language hints |
| Batch alternative | gpt-transcribe at $0.0045 per minute, which also serves the file endpoint |
Moving a live-captioning product off a chunked Whisper deployment. Step one is usually deleting more code than you add.
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.
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.
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.
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.
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.
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.
Per minute of audio, at list. The comparison that decides most architectures is the first two rows.
| GPT-Realtime-Whisper | $0.017 / min | About $1.02 per hour. Streaming transcription sessions. |
|---|---|---|
| GPT-Live-Transcribe | $0.017 / min | Same price, with a latency and accuracy dial plus keyword and language hints. |
| GPT-Transcribe | $0.0045 / min | About $0.27 per hour. File endpoint and transcription sessions. The default for anything not live. |
| GPT-4o Transcribe | about $0.006 / min | Prior generation. $2.50 text in and $10 out on the token path. |
| Whisper v1 | $0.006 / min | Legacy. Undercut by GPT-Transcribe on both price and quality. |
| GPT-Realtime-Translate | $0.034 / min | Speech to speech translation. 70+ input languages, 13 output. |
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.
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.
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.
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.
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.
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.
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.
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.
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.
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-FrameworkDirect 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.
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.
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.
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.
Tokens in, tokens out, dollars spent. Sliced by feature, tenant, and route. Budgets enforced where it matters.
Real distributions, not averages. We know which routes are slow, and why.
The same eval suite that gates a release runs continuously in production. A regression on real traffic surfaces fast.
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.