Apa Itu GPT-Realtime-2 dan Cara Menggunakan API GPT-Realtime-2

OpenAI merilis generasi baru model suara pada 6 November 2026. Rilis utamanya adalah GPT-Realtime-2: model ucapan-ke-ucapan dengan penalaran kelas GPT-5, jendela konteks 128.000 token, dan tingkat penalaran yang dapat dikonfigurasi untuk menyeimbangkan latensi vs kualitas jawaban. Jika Anda sudah memakai gpt-realtime, migrasi utamanya adalah mengganti string model ke gpt-realtime-2 dan menyesuaikan beberapa konfigurasi alat.

Coba Apidog hari ini

Panduan ini fokus pada implementasi: apa itu GPT-Realtime-2, perubahan penting dibanding model sebelumnya, harga, endpoint, contoh WebSocket, input gambar, function calling, MCP, SIP, dan cara menguji sesi Realtime di Apidog tanpa merekam ulang audio setiap kali.

Untuk konteks lini model OpenAI tahun 2026, lihat Apa Itu GPT-5.5. Untuk model multimodal saudaranya, lihat Cara Menggunakan API GPT-Image-2.

TL;DR

• GPT-Realtime-2 adalah model ucapan-ke-ucapan OpenAI dengan penalaran kelas GPT-5, konteks 128k, dan output maksimum 32k token.
• Harga audio: $32 per 1 juta token input dan $64 per 1 juta token output. Input cache audio: $0.40 per 1 juta token.
• Dua suara baru, Cedar dan Marin, eksklusif untuk Realtime API.
• Tingkat penalaran: minimal, low, medium, high, xhigh. Default: low.
• Endpoint WebSocket utama: wss://api.openai.com/v1/realtime?model=gpt-realtime-2.
• SIP didukung untuk panggilan telepon masuk.
• Model pendamping:
  • GPT-Realtime-Translate: terjemahan langsung, 70 bahasa input, $0.034/menit.
  • GPT-Realtime-Whisper: STT streaming, $0.017/menit.
• Gunakan Apidog untuk menyimpan skrip WebSocket, menangkap frame, dan membandingkan event antar eksekusi.

Apa itu GPT-Realtime-2?

GPT-Realtime-2 adalah model ucapan-ke-ucapan tunggal. Anda mengirim audio masuk, menerima audio keluar, dan model menangani transkripsi, penalaran, pemilihan alat, serta pembuatan suara dalam satu alur.

Artinya, Anda tidak perlu membangun pipeline terpisah seperti:

Speech-to-Text -> LLM -> Text-to-Speech

Dengan Realtime API, pipeline tersebut digantikan oleh satu sesi event-driven.

GPT-Realtime-2 menerima input teks, audio, dan gambar. Output-nya berupa teks dan audio. Input gambar adalah tambahan penting: Anda dapat mengirim screenshot atau foto ke percakapan langsung, lalu pengguna melanjutkan percakapan secara lisan.

Contoh kasus:

• Agen support melihat screenshot error pengguna.
• Kopilot teknisi membaca foto panel kabel.
• Asisten aksesibilitas menjelaskan UI yang sedang dibuka pengguna.

Spesifikasi ringkas:

Apa yang berubah dibandingkan gpt-realtime

Dibandingkan gpt-realtime-1.5, GPT-Realtime-2 meningkat pada benchmark audio:

• Big Bench Audio: 81.4% → 96.6%.
• Audio MultiChallenge: 34.7% → 48.5%.

Skor tersebut diperoleh pada tingkat penalaran high dan xhigh. Untuk produksi, default-nya adalah low agar latensi tetap rendah.

Perubahan yang paling relevan untuk developer:

1. Konteks lebih besar

   • Dari 32k menjadi 128k token.
   • Cocok untuk sesi support panjang, tutoring, onboarding, dan panggilan telepon.

2. Penalaran dapat dikonfigurasi

   • Gunakan low untuk latensi rendah.
   • Naikkan ke medium atau high hanya jika kualitas jawaban tidak cukup.

3. Audio lebih natural

   • Model dapat memberi frasa pembuka seperti “sebentar, saya cek dulu” untuk menutupi latensi penalaran.

4. Tool call paralel

   • Model dapat menjalankan beberapa fungsi sekaligus sambil tetap menarasikan progres.

5. Pemulihan lebih baik

   • Giliran ambigu atau interupsi pengguna lebih mudah ditangani tanpa memulai ulang percakapan.

Harga

GPT-Realtime-2 ditagih per token dengan tarif berbeda untuk teks, audio, dan gambar.

Input cache mengurangi biaya untuk konteks berulang. Jika agen Anda memakai system prompt stabil, instruksi panjang, atau dokumen referensi yang sama, desain sesi agar cache tetap terpakai.

Untuk perbandingan harga dengan model lain, lihat harga GPT-5.5.

Model pendamping ditagih per menit:

• GPT-Realtime-Translate: $0.034/menit.

  • Mendukung 70 bahasa input dan 13 bahasa output.
  • Word Error Rate 12.5% lebih rendah daripada model lain yang diuji dalam bahasa Hindi, Tamil, dan Telugu.

• GPT-Realtime-Whisper: $0.017/menit.

  • Untuk streaming speech-to-text.
  • Cocok untuk caption langsung dan transkripsi berkelanjutan.

Pilih model berdasarkan kebutuhan:

Endpoint dan autentikasi

Endpoint yang relevan:

POST https://api.openai.com/v1/chat/completions
POST https://api.openai.com/v1/responses
WSS  wss://api.openai.com/v1/realtime?model=gpt-realtime-2
WSS  wss://api.openai.com/v1/realtime?call_id={call_id}   # untuk SIP
POST https://api.openai.com/v1/realtime/translations
POST https://api.openai.com/v1/realtime/transcription_sessions

Untuk agen suara real-time, gunakan WebSocket:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2

Header autentikasi:

Authorization: Bearer $OPENAI_API_KEY
OpenAI-Beta: realtime=v1

Simpan API key sebagai environment variable:

export OPENAI_API_KEY="sk-proj-..."

Menghubungkan melalui WebSocket

Berikut klien Node.js minimal menggunakan package ws.

Install dependency:

npm install ws

Contoh koneksi:

import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.openai.com/v1/realtime?model=gpt-realtime-2",
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "OpenAI-Beta": "realtime=v1",
    },
  }
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      voice: "cedar",
      instructions: "You are a friendly support agent for a fintech app.",
      input_audio_format: "pcm16",
      output_audio_format: "pcm16",
      turn_detection: { type: "server_vad" },
      reasoning: { effort: "low" },
    },
  }));
});

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

  if (event.type === "response.audio.delta") {
    // base64 PCM16 audio chunk
    // kirim ke speaker, browser, atau pipeline audio Anda
    process.stdout.write(Buffer.from(event.delta, "base64"));
  }

  if (event.type === "response.done") {
    console.log("Response complete");
  }
});

ws.on("error", console.error);

Alur dasar sesi:

1. Buka koneksi WebSocket.
2. Kirim session.update untuk mengatur suara, instruksi, format audio, VAD, dan reasoning.
3. Saat pengguna berbicara, kirim chunk audio lewat input_audio_buffer.append.
4. Saat giliran pengguna selesai, trigger respons.
5. Terima audio keluar lewat response.audio.delta.

Contoh mengirim audio base64:

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

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

  ws.send(JSON.stringify({
    type: "response.create",
  }));
}

PCM16 pada 24 kHz adalah default yang aman. Untuk sistem telepon, G.711 mu-law dan A-law juga didukung.

Untuk membandingkan Realtime API dengan Responses API, lihat Cara Menggunakan API GPT-5.5.

Konfigurasi suara

Dua suara baru:

• Cedar

  • Suara pria.
  • Hangat, rentang menengah.
  • Cocok untuk agen support umum.

• Marin

  • Suara wanita.
  • Cerah dan jernih.
  • Cocok untuk pengumuman dan terjemahan.

Keduanya eksklusif untuk Realtime API.

Suara lama juga tetap tersedia:

alloy
ash
ballad
coral
echo
sage
shimmer
verse

Untuk mengganti suara di tengah sesi, kirim session.update lagi:

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    voice: "marin",
  },
}));

Mengirim input gambar

Anda dapat melampirkan gambar ke giliran pengguna. Polanya sama seperti membuat item percakapan baru.

ws.send(JSON.stringify({
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_image",
        image_url: "https://example.com/screenshot.png",
      },
      {
        type: "input_text",
        text: "What does this error mean?",
      },
    ],
  },
}));

ws.send(JSON.stringify({
  type: "response.create",
}));

Pola implementasi yang umum:

• QA berbasis suara

  • Tester mengirim screenshot UI rusak.
  • Agen menjelaskan masalah dan membantu membuat laporan bug.

• Dukungan lapangan

  • Teknisi mengirim foto perangkat.
  • Agen memandu langkah diagnostik.

• Aksesibilitas

  • Agen menarasikan tampilan layar pengguna selama panggilan support.

Untuk detail model gambar OpenAI, lihat Cara Menggunakan API GPT-Image-2.

Pemanggilan fungsi dan MCP

GPT-Realtime-2 mendukung function calling standar dan server MCP jarak jauh dalam sesi yang sama.

Function calling standar

Alurnya:

1. Deklarasikan tool di konfigurasi sesi.
2. Model mengeluarkan event response.function_call_arguments.delta.
3. Aplikasi Anda mengeksekusi fungsi.
4. Kirim hasilnya kembali lewat conversation.item.create dengan tipe function_call_output.
5. Trigger respons lanjutan jika diperlukan.

Contoh deklarasi tool:

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [
      {
        type: "function",
        name: "lookup_account",
        description: "Look up a customer account by account ID.",
        parameters: {
          type: "object",
          properties: {
            account_id: {
              type: "string",
            },
          },
          required: ["account_id"],
        },
      },
    ],
  },
}));

Hal penting di GPT-Realtime-2: model dapat melakukan panggilan paralel dan tetap berbicara kepada pengguna, misalnya “saya sedang memeriksa saldo dan tiga transaksi terakhir Anda.”

MCP jarak jauh

Dengan MCP, Anda dapat mendaftarkan server tool jarak jauh langsung di sesi.

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [{
      type: "mcp",
      server_url: "https://mcp.example.com/sse",
      allowed_tools: ["lookup_account", "list_transactions"],
    }],
  },
}));

Gunakan MCP jika katalog tool Anda besar atau Anda ingin memisahkan runtime agen suara dari runtime tool.

Jika Anda menguji server MCP sebelum menghubungkannya ke agen suara, lihat panduan pengujian server MCP di Apidog.

Panggilan telepon SIP

GPT-Realtime-2 juga dapat digunakan untuk panggilan telepon sungguhan.

Alur umumnya:

1. Arahkan trunk SIP Anda ke gateway SIP OpenAI.
2. Panggilan masuk membuat sesi Realtime.
3. Aplikasi Anda terhubung ke:

wss://api.openai.com/v1/realtime?call_id={call_id}

Model menerima G.711 mu-law dan A-law secara langsung, sehingga bridge Anda tidak perlu melakukan transkoding tambahan.

Kombinasi SIP + tool calling + MCP cocok untuk:

• Agen call center.
• Verifikasi akun.
• Status pesanan.
• Penjadwalan.
• Eskalasi support.

Mengatur tingkat penalaran

Tingkat penalaran mengontrol trade-off antara latensi dan kualitas jawaban.

Rekomendasi praktis:

• Mulai dari low.
• Ukur latensi dan kualitas respons.
• Naikkan ke medium jika terjadi salah paham pada instruksi kompleks.
• Gunakan high atau xhigh hanya untuk skenario yang benar-benar membutuhkan penalaran berat.

Contoh konfigurasi:

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    reasoning: {
      effort: "low",
    },
  },
}));

Menguji Realtime API di Apidog

Debugging WebSocket dari terminal cepat menjadi sulit karena percakapan memiliki state, banyak event, dan audio berbentuk chunk. Apidog membantu Anda menyimpan konfigurasi dan memutar ulang sesi.

Workflow yang bisa Anda pakai:

1. Buat request WebSocket baru.
2. Masukkan URL:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2

1. Tambahkan header:

Authorization: Bearer {{OPENAI_API_KEY}}
OpenAI-Beta: realtime=v1

1. Simpan OPENAI_API_KEY sebagai environment variable.
2. Buat skrip pesan JSON:
   • session.update
   • input_audio_buffer.append
   • input_audio_buffer.commit
   • response.create
3. Jalankan koneksi dan tangkap semua event server.
4. Bandingkan hasil saat Anda mengubah:
   • voice
   • reasoning.effort
   • instruksi sistem
   • daftar tool
   • format audio

Unduh Apidog, buat request WebSocket baru, lalu tempel bearer token Anda di bagian Auth.

Untuk perbandingan dengan model multimodal cepat lain, lihat Cara Menggunakan API Pratinjau Gemini 3 Flash.

Checklist implementasi produksi

Sebelum membawa agen suara ke produksi, pastikan hal-hal berikut:

• [ ] Gunakan gpt-realtime-2 pada URL WebSocket.
• [ ] Simpan API key di environment variable, bukan hardcoded.
• [ ] Mulai dengan reasoning.effort: "low".
• [ ] Pilih format audio sesuai platform:
  • PCM16 untuk aplikasi web/native.
  • G.711 untuk telepon.
• [ ] Aktifkan server_vad jika ingin model menangani interupsi pengguna.
• [ ] Batasi tool yang tersedia dengan allowlist.
• [ ] Log event penting:
  • response.audio.delta
  • response.done
  • function call events
  • error events
• [ ] Ukur token input/output audio.
• [ ] Gunakan input cache untuk instruksi atau konteks berulang.
• [ ] Uji skenario interupsi, koneksi putus, dan tool timeout.

FAQ

ID model apa yang harus digunakan?

Gunakan:

gpt-realtime-2

Model sebelumnya masih tersedia sebagai gpt-realtime jika Anda perlu rollback. Versi lite, gpt-realtime-2-mini, juga sudah aktif.

Bisakah input audio dikirim saat output audio masih diputar?

Ya. Realtime API menggunakan server-side voice activity detection secara default. Model dapat berhenti berbicara saat pengguna mulai berbicara.

Anda juga dapat menonaktifkan VAD dan mengatur batas giliran dari klien.

Apakah konteks 128k termasuk token audio?

Ya. Audio ditokenisasi. Satu detik audio kira-kira 50 token tergantung format. Panggilan support panjang dapat menghabiskan konteks lebih cepat daripada chat teks.

Apakah fine-tuning didukung?

Belum. Sesuai kartu model, GPT-Realtime-2 belum mendukung fine-tuning, predicted outputs, atau streaming teks pada Chat Completions. Endpoint Realtime secara inheren melakukan streaming audio.

Bagaimana dibandingkan GPT-5.5 dengan TTS?

GPT-Realtime-2 melakukan penalaran ucapan end-to-end. Model yang peka suara dapat menangkap nada, keraguan, dan penekanan pengguna. Model teks + TTS tidak menangkap sinyal suara dengan cara yang sama.

Untuk penalaran teks murni, lihat Cara Menggunakan API GPT-5.5.

Batas tarif apa yang berlaku?

Tingkat 1 dimulai dari 40.000 token per menit dan meningkat hingga 15 juta TPM pada Tingkat 5. Batas tarif berlaku per model, jadi kuota GPT-5 yang ada tidak otomatis terbawa.

Kesimpulan

GPT-Realtime-2 membuat agen suara lebih praktis untuk produksi: konteks 128k, penalaran kelas GPT-5, input gambar, MCP, function calling paralel, dan SIP berada dalam satu permukaan Realtime API.

Jalur implementasi paling aman:

1. Buat sesi WebSocket dasar.
2. Mulai dengan reasoning.effort: "low".
3. Kunci daftar tool.
4. Uji input audio, interupsi, dan error handling.
5. Rekam dan bandingkan event WebSocket di Apidog.
6. Naikkan tingkat penalaran hanya jika metrik kualitas membutuhkannya.