GPT Transcribe vs. GPT Live Transcribe: File and Realtime Speech-to-Text Guide

OpenAI officially released two speech transcription models on July 28, 2026: gpt-transcribe and gpt-live-transcribe. Both are part of the Audio API and Realtime transcription system, but they address different issues.

• gpt-transcribe: Process the finished audio file or transcribe the complete voice segment already submitted in Realtime.
• gpt-live-transcribe: Continuously receive live audio and return incremental text as soon as possible.

They all support free-format context, keyword prompts, and multiple expected input languages, making them suitable for meeting minutes, customer service calls, live subtitles, voice search, and multilingual recording organization.

First, select the model by audio arrival method

The most easily confused is the term “streaming.” Files that have already been recorded can also stream back part of the text during processing, but the audio itself is already intact and does not require establishing a Realtime session. Only when audio is still continuously arriving from microphones, phones, or media streams is gpt-live-transcribe and persistent real-time connections are needed.

Differences in capabilities between the two models

If a business must obtain word timestamps, SRTs, or VTTs, official transcription guidelines still recommend using whisper-1. When speaker labels are needed, file transcription models should be used gpt-4o-transcribe-diarize, rather than requiring these two models to guess the speaker.

Prepare the SDK and API Key

Installing or updating the Python SDK:

1

pip install -U openai

Set API Key:

1

$env:OPENAI_API_KEY = "你的_API_Key"

Do not write API keys into scripts, frontend code, or Git repositories. When browsers use Realtime API via WebRTC, short-term client credentials should be created by the backend, not sent to the browser with long-term server keys.

Transcribing audio files with GPT Transcribe

File transcription calls /v1/audio/transcriptions. Below is the basic syntax of the official Python SDK:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from openai import OpenAI

client = OpenAI()

with open("meeting.wav", "rb") as audio_file:
    transcription = client.audio.transcriptions.create(
        model="gpt-transcribe",
        file=audio_file,
    )

print(transcription.text)

The corresponding cURL request is as follows:

1
2
3
4
5

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="@/path/to/file/meeting.wav"

Common formats listed in the file transcription guide include:

• mp3
• mp4
• mpeg
• mpga
• m4a
• wav
• webm

The maximum size per file is 25 MB. Larger recordings should be compressed or split first, keeping each segment under 25 MB. When splitting, try to choose pauses or sentence boundaries; avoid truncating between names, numbers, or complete sentences, or adjacent clips will lose semantic context.

Use Context to Improve Recognition of Technical Terms

Both new models accept three types of transscripted contexts:

• prompt: Describe the recording theme, scene, or background.
• keywords: Product names, abbreviations, and proprietary terms that may appear in the audio.
• languages: One or more input languages expected to appear.

File transcription example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from openai import OpenAI

client = OpenAI()

with open("support-call.wav", "rb") as audio_file:
    transcription = client.audio.transcriptions.create(
        model="gpt-transcribe",
        file=audio_file,
        prompt="一段关于高级套餐和账户 AC-42 的客户支持通话。",
        extra_body={
            "keywords": ["高级套餐", "AC-42", "账单"],
            "languages": ["zh-cn", "en"],
        },
    )

print(transcription.text)

prompt Information related to the recording should be provided, without repeating tasks like “Please convert audio to text.” keywords It is only a hint, not a vocabulary list the model must output. If a keyword is missing in the audio, the transcription result should not be added out of thin air. Too many keywords or irrelevant to the content may trigger unspoken words to appear in the results. Before going live, compare the actual error rate with or without keywords.

How languages Differs from the Old language Parameter

gpt-transcribe and gpt-live-transcribe use the plural parameter languages; do not send old singular language at the same time. Officially supported language code formats include:

• ISO 639-1, such as en, es, fr.
• Parts of ISO 639-3, such as eng, spa, yue, cmn.
• Chinese regional codes, such as zh-cn, zh-tw, zh-hk.

Unsupported or incorrectly formatted language code will be rejected by the API. Multilingual calls can provide multiple candidate languages, but do not cram completely unrelated languages into the request. Keywords must keep one value per line and cannot contain <, >, carriage returns, or newline characters. When these characters are encountered, file requests or Realtime session updates will be rejected as a whole.

Create GPT Live Transcribe Sessions

The type of real-time transcription session is transcription. The server-side audio pipeline typically uses WebSocket, while browser microphone scenarios typically use WebRTC. The following session.update uses 24 kHz PCM audio and turns off automatic voice turn detection:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

{
  "type": "session.update",
  "session": {
    "type": "transcription",
    "audio": {
      "input": {
        "format": {
          "type": "audio/pcm",
          "rate": 24000
        },
        "transcription": {
          "model": "gpt-live-transcribe",
          "prompt": "一场包含中英文产品名称的技术支持通话。",
          "keywords": ["OpenAI", "Realtime API", "AC-42"],
          "languages": ["zh-cn", "en"],
          "delay": "low"
        },
        "turn_detection": null
      }
    }
  }
}

After turning off automatic round detection, the app needs to decide for itself when to end a voice clip. Audio data is appended after encoding with Base64:

1
2
3
4
5
6

ws.send(
  JSON.stringify({
    type: "input_audio_buffer.append",
    audio: base64Pcm16,
  })
);

Explicit submission at the end of the clip:

1
2
3
4
5

ws.send(
  JSON.stringify({
    type: "input_audio_buffer.commit",
  })
);

You can also configure server-side VAD to have the system detect the start and end of speaking and automatically submit the turn.

Handling incremental text and final results

gpt-live-transcribe first sends the incremental event, then sends the full result of that voice round.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

ws.on("message", (data) => {
  const event = JSON.parse(data);

  if (event.type === "conversation.item.input_audio_transcription.delta") {
    process.stdout.write(event.delta);
  }

  if (event.type === "conversation.item.input_audio_transcription.completed") {
    console.log("\nFinal transcript:", event.transcript);
  }
});

The interface should not treat every delta as permanent text. Subsequent increments or final results may correct previous content, so an updatable subtitle buffer should be designed.

Completion events for different voice rounds are not guaranteed to arrive in the order of commits. You must use item_id to associate delta, final text, and original audio clips; you cannot rely solely on WebSocket message arrival time for sorting.

Tune Realtime Transcription Latency

gpt-live-transcribe Allows delay to adjust latency and accuracy:

The level does not correspond to a fixed millisecond count. Actual latency varies with model configuration, audio, and network, so you can’t rigidly write a test result as a service commitment.

Lower latency allows parts of the text to appear earlier, while higher latency allows the model to hear more context before output, which usually helps reduce word error rates.

Realtime mode for transcription after committing

If the application already uses Realtime WebSocket but does not need to display text while speaking, it can select gpt-transcribe in the session.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
  "type": "session.update",
  "session": {
    "type": "transcription",
    "audio": {
      "input": {
        "format": {
          "type": "audio/pcm",
          "rate": 24000
        },
        "transcription": {
          "model": "gpt-transcribe"
        },
        "turn_detection": null
      }
    }
  }
}

The app first appends audio and then sends input_audio_buffer.commit. The model can generate text increments before the final completion event, which also includes the detected language.

If the language cannot be reliably determined, languages will be an empty array. gpt-live-transcribe does not provide this detection language result.

In dedicated transcription sessions or Realtime input transcription, gpt-transcribe automatically uses previously transcribed rounds as context, helping to maintain terminology consistency in continuous conversations.

How to test production environments

Do not accept only standard Mandarin samples from quiet rooms. Test sets should cover real usage conditions:

• Target language, accent, and switching languages midway.
• Phone narrowband audio, different microphones, and background noise.
• Name, date, amount, email, order number, and alphanumeric string.
• Product names, drug names, abbreviations, and industry terms.
• Very short answers, long recordings, interruptions, and interruptions.
• Network jitter, connection reconstruction, and repeated commits.

In addition to the overall word error rate, it is also necessary to count errors that are truly important to the business. Customer service systems should separately evaluate order numbers and account numbers, while medical scenarios should separately evaluate drug names and dosages.

The real-time interface should also record:

• Delay in the arrival of the first delta.
• Final results are delayed.
• Empty transcription, truncation, and prolonged inactivity.
• delta is the proportion of the final text corrected.
• Accuracy differences across different delay levels.

Frequently Asked Questions

Is Streaming a File Transcript the Same as Realtime?

Not equal. Files can stream back text during processing, but the input audio has already been fully uploaded; Realtime is used for live audio that is still continuously arriving.

Can two models generate subtitle timelines?

They do not provide word-level timestamps. When word or sectional timestamps, SRT, VTT are needed, whisper-1 should be chosen according to the official guidelines.

Can GPT Live Transcribe distinguish speakers?

Speaker tags cannot be returned. When speaker separation is required, compatible file transcription models or application-level post-processing solutions should be used.

Are More Keywords Always Better?

No. Keywords are just identification prompts; too many irrelevant words may increase the risk of unspoken words being written into the results.

Should Multilingual Audio Use language or languages?

These two new models use languages. Do not send language and languages at the same time.

Summary

gpt-transcribe Suitable for completed files, limited audio requests, and complete voice rounds processed after submission in Realtime.

gpt-live-transcribe Suitable for microphones, phone calls, and live audio streams, continuously returns low-latency text increments, and adjusts speed and accuracy through delay.

Whichever you choose, prompt, keywords, and languages should be treated as prompts for real audio evaluation, rather than as a rigid constraint guaranteeing specific text to appear.

Official Resources

• OpenAI API Release Log
• GPT Transcribe Model Documentation
• GPT Live Transcribe Model Documentation
• Overview of Transcription Workflow
• File Transcription Guide
• Realtime Transliteration Guide