DEV Community

Ahab
Ahab

Posted on • Originally published at indieseek.co

GPT Transcribe vs GPT Live Transcribe: Workflow Checklist

GPT Transcribe vs GPT Live Transcribe: choose the right speech-to-text workflow

Quick answer

OpenAI released gpt-transcribe and gpt-live-transcribe on July 28, 2026. They are not interchangeable names for one streaming model:

  • Use gpt-transcribe for a completed recording or bounded audio request through /v1/audio/transcriptions. It can return one final transcript or stream partial text while the uploaded file is processed.
  • Use gpt-live-transcribe when audio is still arriving from a microphone, call, or media stream. Run it in a Realtime transcription session over WebRTC or WebSocket.
  • Use gpt-transcribe inside a Realtime WebSocket session only when transcription should begin after an audio turn is committed or the application needs detected-language output.
  • Keep a specialized file model when the output contract requires speaker labels, word timestamps, srt or vtt, or translation into English.

The important decision is when the audio exists, not whether the interface wants partial text. A completed file can stream output without opening a Realtime connection.

Who this is for

This guide is for developers adding captions, meeting notes, support-call transcripts, voice search, or audio review to an application. It focuses on choosing and operating the new transcription models, not on building a conversational voice agent.

For an indie product, keep the first rollout narrow: one audio source, a representative eval set, bounded context hints, and a visible fallback. Pair the usage plan with the OpenAI API hard spend-limit runbook before sending production traffic.

What changed and why it matters

gpt-transcribe is OpenAI's recommended starting model for recorded speech. It handles completed files, streamed file transcripts, and committed turns in Realtime. The model accepts free-form prompt context, literal keywords, and multiple expected languages. Its completed response can include detected languages.

gpt-live-transcribe is the low-latency path for audio that is arriving now. It emits transcript deltas and a final transcript per committed item. Its delay setting trades earlier partial text for more audio context; OpenAI documents minimal, low, medium, high, and xhigh, but does not promise fixed milliseconds for those labels.

The official model pages currently list $0.0045 per audio minute for GPT Transcribe and $0.017 per realtime audio minute for GPT Live Transcribe. Treat those as rates checked on July 29, 2026, not a permanent constant.

Choose the architecture

Input and output need Start with Connection Important boundary
Completed file, final text gpt-transcribe HTTP upload Files are limited to 25 MB
Completed file, progressive text gpt-transcribe with stream=true HTTP + SSE response Streaming output is not live input
Microphone, call, or media stream gpt-live-transcribe WebRTC or WebSocket Reconcile deltas and finals by item_id
Committed live turn plus detected language gpt-transcribe Realtime WebSocket Transcription starts after commit
Speaker labels gpt-4o-transcribe-diarize File transcription Not available in Realtime transcription
Word timestamps, srt, vtt, or English translation whisper-1 File transcription Use only for the specialized output requirement

Do not select Live Transcribe merely because the UI wants typing-like feedback. If the complete file already exists, the file endpoint is simpler and cheaper at the current posted rates.

Implement the smallest file path

Start with one bounded recording and explicit context:

curl https://api.openai.com/v1/audio/transcriptions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F model="gpt-transcribe" \
  -F file="@support-call.wav" \
  -F 'prompt=A support call about an IndieSeek subscription.' \
  -F 'keywords[]=IndieSeek' \
  -F 'keywords[]=license key' \
  -F 'languages[]=en' \
  -F 'languages[]=zh-cn'
Enter fullscreen mode Exit fullscreen mode

Use prompt for the setting, keywords for literal terms that may be spoken, and languages for expected input languages. Keywords are hints, not required output. Reject a hint configuration that inserts an unspoken product name.

For a progressive response from the same completed file, add stream=true. Expect transcript.text.delta events followed by transcript.text.done; do not add a persistent Realtime session solely for this presentation choice.

Implement the smallest live path

Create a Realtime transcription session and decide whether the server or the application owns turn boundaries:

{
  "type": "session.update",
  "session": {
    "type": "transcription",
    "audio": {
      "input": {
        "format": { "type": "audio/pcm", "rate": 24000 },
        "transcription": {
          "model": "gpt-live-transcribe",
          "keywords": ["IndieSeek", "license key"],
          "languages": ["en", "zh-cn"],
          "delay": "low"
        },
        "turn_detection": null
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

With turn detection disabled, append audio chunks and send input_audio_buffer.commit when the turn ends. Render delta events as provisional text, then replace that text with the completed event. Completion events from different turns are not guaranteed to arrive in order, so key UI state and persistence by item_id, not arrival sequence.

Build a representative eval before rollout

Use six samples that resemble production:

  1. Clean speech in the primary language.
  2. Background noise or telephony-quality audio.
  3. An accent or regional pronunciation.
  4. Code-switching between expected languages.
  5. Product names, IDs, dates, currency, and email addresses.
  6. Interrupted speech and a long turn.

Run three context variants on the same audio: no hints, prompt only, then bounded keywords plus languages. Score the fields your product actually uses—names, IDs, amounts, commands, and language—along with time to first delta, finalization time, partial-text revision rate, empty output, and truncation. Word error rate alone can hide the failure that matters.

If the workflow resembles SingLine Coach, retain the original audio long enough for an authorized reviewer to compare the transcript, then apply the product's deletion and privacy policy. A transcription feature does not justify broader data retention or agent access; use the same authority discipline as an AI coding sandbox.

Eight production gates

Gate Passing evidence
Route choice File and live inputs reach their intended model and transport
Audio boundary Oversized files are compressed or split away from sentence boundaries
Context ablation Hints improve target terms without inserting unspoken keywords
Multilingual path Every supported language and code-switch pattern passes the task score
Event reconciliation Deltas are provisional; finals replace them by item_id
Latency budget Measured first-delta and final times meet the product threshold
Specialized fallback Timestamp, subtitle, diarization, or confidence needs route elsewhere
Failure and cost Empty, delayed, rejected, and quota-limited requests have visible recovery

Copyable rollout record 

transcription_rollout:
  input: "completed-file | live-audio | committed-turn"
  model: "gpt-transcribe | gpt-live-transcribe | specialized fallback"
  transport: "http | http-sse | webrtc | websocket"
  context: ["prompt", "bounded keywords", "expected languages"]
  eval_set: "six representative samples"
  quality_gate: "task fields plus error categories"
  latency_gate: "measured first delta and final transcript"
  event_key: "item_id for realtime"
  cost_limit: "project hard limit and application budget"
  fallback: "retry only proven transient failures; otherwise preserve audio and report"
Enter fullscreen mode Exit fullscreen mode

This is an operating template, not an OpenAI API schema.

Common mistakes

Equating streamed output with live input. A completed file can stream transcription events through the file endpoint.

Using the cheapest clean-audio demo as the eval. Real microphones, calls, accents, interruptions, and domain terms decide whether the workflow works.

Dumping every possible term into keywords. Hints need an ablation test because an unspoken term appearing in the transcript is a product failure.

Appending deltas as permanent text. Partial text can change. Reconcile it with the final event and keep turns keyed by item_id.

Forcing one model to satisfy every output contract. Live Transcribe does not provide word timestamps, speaker labels, or confidence scores. Route those needs explicitly.

FAQ

Is GPT Live Transcribe always better for streaming?

No. It is for live audio arriving over a persistent connection. For an already completed file, use gpt-transcribe; it can stream partial output during processing.

Can GPT Transcribe be used in Realtime?

Yes, for committed-turn transcription over WebSocket or when detected-language output is needed. It is not the default low-latency path for continuously arriving audio.

Should an existing Whisper integration be replaced immediately?

Not when the application depends on word timestamps, srt, vtt, or translation into English. Preserve the specialized output contract, then evaluate a separate general-transcription path.

Sources

Top comments (0)