GPT-Live vs GPT-Realtime: เลือกใช้ OpenAI Voice Stack ตัวไหนดีที่สุด?

OpenAI มีเทคโนโลยีเสียงสองตัวที่ชื่อใกล้กัน และการประกาศ GPT-Live เมื่อวันที่ 8 กรกฎาคมทำให้หลายคนสับสน: ค้นหา “GPT Live API” แล้วมักเจอเอกสาร GPT-Realtime; อ่านข่าวเปิดตัวแล้วก็พบว่าชื่อถูกใช้ปะปนกัน ทั้งที่จริงแล้วสองอย่างนี้ไม่เหมือนกัน

ลองใช้ Apidog วันนี้

สรุปสั้นๆ: GPT-Live คือประสบการณ์เสียงสำหรับผู้ใช้ทั่วไปใน ChatGPT ส่วน GPT-Realtime คือชุด API สำหรับนักพัฒนาเพื่อสร้างแอปพลิเคชันเสียงของตัวเอง ถ้าคุณกำลังจะเขียนโค้ด ให้โฟกัสที่ GPT-Realtime ก่อน เพราะเป็น API ที่เปิดใช้งานแล้วในปัจจุบัน

GPT-Live vs GPT-Realtime: ตารางเปรียบเทียบสำหรับนักพัฒนา

หัวข้อ	GPT-Live	GPT-Realtime
คืออะไร	กลุ่มโมเดลเสียงที่ขับเคลื่อน ChatGPT Voice	โมเดล Speech-to-speech ใน Realtime API
สำหรับใคร	ผู้ใช้ ChatGPT	นักพัฒนาที่สร้างผลิตภัณฑ์เสียง
ทำงานที่ไหน	แอป ChatGPT บน iOS, Android, เว็บ และ CarPlay	แอปพลิเคชันของคุณผ่าน API
การเข้าถึง API	ยังไม่มี OpenAI ระบุว่า “ในไม่ช้า”	เปิดให้ใช้งานทั่วไปแล้ว
โมเดลปัจจุบัน	GPT-Live-1, 1 mini, 1 Medium, 1 High	gpt-realtime, gpt-realtime-1.5, gpt-realtime-2.1, 2.1-mini
สถาปัตยกรรม	Full-duplex + การมอบหมายงานเบื้องหลังไปยัง GPT-5.5	โมเดล Speech-to-speech เดี่ยว ทำงานแบบผลัดเปลี่ยนรวดเร็ว
รูปแบบการสนทนา	ฟังขณะพูดและสื่อสารกลับ	การผลัดเปลี่ยนที่ความหน่วงต่ำ พร้อมจัดการการขัดจังหวะ
คุณสมบัติเพิ่มเติม	การค้นหาเว็บ, การแปล, การ์ดภาพ, หน่วยความจำ	Function calling, เซิร์ฟเวอร์ MCP, การโทร SIP, การรับข้อมูลรูปภาพ
ราคา	ยังไม่เผยแพร่ รวมอยู่ในระดับสมาชิก ChatGPT	เผยแพร่แล้ว เช่น gpt-realtime ราคา $4/M ขาเข้า, $16/M ขาออก

GPT-Live คืออะไร

GPT-Live คือค่าเริ่มต้นใหม่ของ ChatGPT Voice เป็นโมเดล Full-duplex ที่ประมวลผลเสียงขาเข้าพร้อมกับสร้างเอาต์พุต โดยตัดสินใจหลายครั้งต่อวินาทีว่าจะพูด ฟัง หยุดชั่วคราว หรือขัดจังหวะ

เมื่อคำถามต้องการการค้นหาหรือการให้เหตุผลที่ลึกขึ้น GPT-Live สามารถมอบหมายงานให้โมเดลอื่น เช่น GPT-5.5 แล้วนำผลลัพธ์กลับมาใช้ในบทสนทนาได้

สิ่งสำคัญสำหรับนักพัฒนา: ตอนนี้คุณยังไม่ได้ integrate GPT-Live เข้ากับแอปของคุณโดยตรง คุณใช้งานมันผ่านแอป ChatGPT เท่านั้น

แนวทางใช้งานปัจจุบัน:

1. เปิดแอป ChatGPT บนแพลตฟอร์มที่รองรับ
2. ใช้ ChatGPT Voice
3. ผู้ใช้แบบเสียเงินจะใช้ GPT-Live-1 เป็นค่าเริ่มต้น
4. ผู้ใช้ฟรีจะได้ GPT-Live-1 mini

ดูรายละเอียดเพิ่มเติมได้ที่คู่มือการตั้งค่า GPT-Live

GPT-Realtime คืออะไร

GPT-Realtime คือกลุ่มโมเดลใน Realtime API ของ OpenAI เป็นโมเดล Speech-to-speech ที่เชื่อมต่อผ่าน WebSocket หรือ WebRTC และรองรับ SIP สำหรับการโทรศัพท์ รวมถึงเซิร์ฟเวอร์ MCP ระยะไกลสำหรับการใช้งานเครื่องมือ

นี่คือเทคโนโลยีที่คุณควรใช้ถ้าต้องการสร้าง:

• voice assistant ในเว็บหรือแอป
• call agent ผ่านโทรศัพท์
• ระบบสนทนาด้วยเสียงแบบ low latency
• voice bot ที่เรียก function หรือ tool ภายนอก
• prototype ที่ต้องรับ event แบบ realtime

โมเดลล่าสุดที่กล่าวถึงในชุดนี้คือ gpt-realtime-2.1 และ 2.1-mini ซึ่งเปิดตัวเมื่อวันที่ 6 กรกฎาคม 2026 สองวันก่อนการประกาศ GPT-Live

คู่มือที่เกี่ยวข้อง:

• คำแนะนำ gpt-realtime ฉบับดั้งเดิม
• GPT-Realtime-2
• GPT-Realtime-2.1-mini

ถ้าคุณกำลังพัฒนาด้วยเทคโนโลยีนี้ Apidog สามารถขับเคลื่อนเซสชัน WebSocket ได้โดยตรง ทำให้การดีบัก Realtime API กลายเป็นสตรีม event ที่ตรวจสอบได้ คุณสามารถดาวน์โหลดฟรี แล้วทดสอบเซสชันกับ gpt-realtime-2.1 ได้ในไม่กี่นาที

ถ้าจะสร้างแอปเสียงตอนนี้ ควรเลือกอะไร

ใช้เกณฑ์นี้:

• ต้องการคุยกับ AI ในฐานะผู้ใช้ทั่วไป → ใช้ GPT-Live ใน ChatGPT
• ต้องการให้แอปหรือระบบโทรศัพท์ของคุณคุยกับผู้ใช้ → ใช้ GPT-Realtime ผ่าน Realtime API
• ต้องการ Full-duplex แบบ GPT-Live ในแอปของตัวเอง → ยังไม่พร้อมใช้งานผ่าน API
• ต้องการเตรียมสถาปัตยกรรมไว้รอ GPT-Live API → ออกแบบระบบบน event-driven session และแยก logic การมอบหมายงานออกจาก transport layer

บทความนี้อธิบายทางเลือกใกล้เคียงเพิ่มเติม: มี GPT-Live API หรือไม่?

โครงสร้างการ implement ด้วย GPT-Realtime

สำหรับแอปเสียงที่ใช้ Realtime API โดยทั่วไป คุณควรแยกเป็น 4 ส่วน:

1. Audio input
   
   รับเสียงจากไมโครโฟน เบราว์เซอร์ แอปมือถือ หรือระบบโทรศัพท์

2. Realtime transport
   
   เชื่อมต่อผ่าน WebSocket หรือ WebRTC แล้วส่ง event ไปยัง Realtime API

3. Event handler
   
   ฟัง event ขาออก เช่น ข้อความ เสียง สถานะ หรือการเรียก tool

4. Tool / function layer
   
   แยก business logic เช่น ค้นหาข้อมูลลูกค้า จองคิว หรือเรียก backend API

ตัวอย่างโครงสร้างแบบย่อ:

// ตัวอย่างเชิงโครงสร้างสำหรับ Node.js
// ตรวจสอบ event schema และ authentication ล่าสุดจากเอกสาร OpenAI ก่อนใช้งานจริง

import WebSocket from "ws";

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

ws.on("open", () => {
  console.log("Realtime session connected");

  // ตั้งค่า session ตาม use case ของคุณ
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      modalities: ["audio", "text"]
    }
  }));
});

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

  switch (event.type) {
    case "response.text.delta":
      process.stdout.write(event.delta);
      break;

    case "response.audio.delta":
      // ส่ง audio chunk ไปยัง client หรือ audio output
      break;

    case "response.function_call_arguments.done":
      // เรียก tool/function ของระบบคุณ
      break;

    default:
      console.log("event:", event.type);
  }
});

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

สำหรับการดีบัก ให้เริ่มจากการตรวจสอบ 3 อย่างนี้:

• event ที่ส่งเข้า API ถูกต้องหรือไม่
• event ที่ได้รับกลับมาเรียงตามลำดับที่คาดไว้หรือไม่
• จุดที่เกิด latency อยู่ที่ audio input, network, model response หรือ tool call

ทำไมชื่อ GPT-Live กับ GPT-Realtime ถึงสับสนง่าย

ทั้งสองเทคโนโลยีกำลังเข้าใกล้กันจากคนละทิศทาง:

• GPT-Realtime ทำให้ Speech-to-speech มีความหน่วงต่ำพอสำหรับเอเจนต์ที่ใช้งานจริง
• GPT-Live เพิ่มเลเยอร์ Full-duplex และการมอบหมายงานด้านบน แต่ยังอยู่ใน ChatGPT เท่านั้น

ในเชิงสถาปัตยกรรม GPT-Live ดูเหมือนสิ่งที่ Realtime API รุ่นต่อไปอาจต้องการไปให้ถึง และ OpenAI ระบุว่าโมเดล GPT-Live จะเข้าสู่ API “ในไม่ช้า”

จนกว่าจะถึงตอนนั้น ให้ถือว่า:

ChatGPT Voice experience = GPT-Live
Developer voice API      = GPT-Realtime

เตรียมโค้ดอย่างไรให้รองรับอนาคตของ GPT-Live API

OpenAI ยังไม่ได้ระบุว่า GPT-Live จะเข้ามาใน Realtime API, แทนที่ GPT-Realtime หรือเปิดเป็นบริการแยกต่างหาก โครงสร้างที่มีสี่ตัวแปร เช่น Instant-backed และ GPT-5.5-Thinking-backed ในสองระดับความพยายาม บ่งชี้ว่าอาจมีการแลกเปลี่ยนระหว่าง latency กับ depth ในระดับ session

สำหรับทีมที่กำลังพัฒนาตอนนี้ แนวทางที่ปลอดภัยคือ:

1. ใช้ Realtime API เป็นฐาน

   • เพราะใช้งานได้จริงในปัจจุบัน
   • มีโมเดล เวอร์ชัน และราคาที่ประกาศแล้ว

2. ทำ session ให้เป็น event-driven

   • อย่าผูก logic ทั้งหมดไว้กับ event รูปแบบเดียว
   • แยก handler สำหรับ audio, text, tool call และ error

3. แยก delegation logic

   • ถ้าต้องเรียกโมเดลอื่นหรือ backend อื่น ให้ทำเป็น service แยก
   • อย่า hardcode ไว้ใน transport layer

4. เก็บ abstraction สำหรับ model

   • เช่น VOICE_MODEL=gpt-realtime-2.1
   • ทำให้เปลี่ยน model ได้ง่ายเมื่อ API ใหม่พร้อมใช้งาน

ตัวอย่างการแยกค่า model:

VOICE_MODEL=gpt-realtime-2.1
OPENAI_API_KEY=your_api_key

const model = process.env.VOICE_MODEL || "gpt-realtime-2.1";

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

แนวทางนี้ช่วยให้คุณเปลี่ยนจาก gpt-realtime-2.1 ไปยังโมเดลใหม่ในอนาคตได้โดยไม่ต้องรื้อ logic ทั้งระบบ

คำถามที่พบบ่อย

GPT-Live เหมือนกับ GPT-Realtime หรือไม่?

ไม่เหมือนกัน GPT-Live เป็นเทคโนโลยีเสียงที่ขับเคลื่อน ChatGPT Voice สำหรับผู้ใช้ทั่วไป ส่วน GPT-Realtime เป็นกลุ่มโมเดลสำหรับนักพัฒนาใน Realtime API

ฉันสามารถใช้ GPT-Live ในแอปของตัวเองได้หรือไม่?

ยังไม่ได้ OpenAI วางแผนที่จะเปิดให้ใช้งาน API “ในไม่ช้า” ปัจจุบัน Realtime API ที่มี gpt-realtime-2.1 เป็นทางเลือกที่พร้อมใช้งาน

GPT-Realtime กำลังจะถูกแทนที่ด้วย GPT-Live หรือไม่?

OpenAI ยังไม่ได้ประกาศเช่นนั้น GPT-Realtime ยังคงเปิดให้ใช้งานทั่วไปและได้รับการอัปเดตสองวันก่อนที่ GPT-Live จะเปิดตัว ดังนั้นให้ถือว่าทั้งสองจะอยู่ร่วมกันเป็นสมมติฐานในการวางแผน

อันไหนมีความสามารถมากกว่ากัน?

ทำหน้าที่ต่างกัน GPT-Live มีการสนทนาแบบ Full-duplex และการมอบหมายงานให้ GPT-5.5 ภายใน ChatGPT ส่วน GPT-Realtime มีส่วนสำหรับนักพัฒนา เช่น function calling, MCP, SIP และราคาที่เปิดเผย

ถ้าต้องเริ่มโปรเจกต์ voice AI วันนี้ ควรเริ่มจากอะไร?

เริ่มจาก GPT-Realtime เพราะเป็น API ที่ใช้งานได้จริงในตอนนี้ จากนั้นออกแบบโค้ดแบบ event-driven และแยก model configuration ไว้ เพื่อให้พร้อมเปลี่ยนไปใช้ GPT-Live API หาก OpenAI เปิดให้ใช้งานในอนาคต