OpenAI หั่นราคา API GPT-5.6: Luna ลด 80%, Terra ลด 20% (รายละเอียดราคาใหม่)

OpenAI ปรับลดราคา API ของ GPT-5.6 สองรุ่นเมื่อวันที่ 30 กรกฎาคม 2026: GPT-5.6 Luna ลดราคา 80% เหลือ $0.20 ต่อล้านโทเค็นขาเข้า และ $1.20 ต่อล้านโทเค็นขาออก; GPT-5.6 Terra ลดลง 20% เหลือ $2 และ $12 ตามลำดับ ส่วน GPT-5.6 Sol ซึ่งเป็นโมเดลการให้เหตุผลระดับเรือธง ยังมีราคา $5/$30 เท่าเดิม แต่เพิ่มโหมด Fast ที่เร็วขึ้น 2.5 เท่าในราคา 2 เท่าของอัตรามาตรฐาน

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

หากคุณสร้างโมเดลต้นทุนจากราคาเปิดตัว GPT-5.6 ตัวเลขเดิมไม่ใช้ได้แล้ว บทความนี้สรุปอัตราใหม่ วิธีคำนวณต้นทุนจริง และขั้นตอนปรับ model routing ในระบบของคุณ โดยควรทดสอบพรอมต์เดียวกันกับ Sol, Terra และ Luna แบบเคียงข้างกันก่อนเปลี่ยน production traffic

อัตราค่าบริการใหม่ของ GPT-5.6

ราคาต่อล้านโทเค็น:

โมเดล	ขาเข้าเก่า	ขาเข้าใหม่	ขาออกเก่า	ขาออกใหม่	การเปลี่ยนแปลง
GPT-5.6 Sol	$5.00	$5.00	$30.00	$30.00	ไม่มีการเปลี่ยนแปลง
GPT-5.6 Terra	$2.50	$2.00	$15.00	$12.00	-20%
GPT-5.6 Luna	$1.00	$0.20	$6.00	$1.20	-80%

ราคาใหม่มีผลกับ API ระดับมาตรฐานตั้งแต่วันที่ 30 กรกฎาคม 2026 ส่วนต่างระหว่างรุ่นถูกสุดและแพงสุดเพิ่มจาก 5 เท่าในวันที่เปิดตัวทั่วไปเมื่อ 9 กรกฎาคม เป็น 25 เท่า

ผลต่อ routing ชัดเจนขึ้น:

• ก่อนหน้านี้ การส่งงานจาก Sol ไป Luna ประหยัดได้ประมาณ 80%
• ตอนนี้ การเลือก Luna แทน Sol สามารถลดต้นทุนตามราคา list ได้สูงสุด 96%
• Terra ยังคงเป็นตัวเลือกกลางที่ถูกลง 20% โดยไม่ต้องเปลี่ยนโมเดล

ส่วนลด prompt caching ยังอาจใช้เพิ่มเติมจากอัตรานี้ แต่ OpenAI ยังไม่ได้เผยแพร่ราคา cached input แยกสำหรับ Luna และ Terra ใหม่ ตรวจสอบหน้าการกำหนดราคาอย่างเป็นทางการก่อนปรับ forecast ที่พึ่งพา cache read

เกิดอะไรขึ้นกับ GPT-5.6 Sol

ราคา list ของ Sol ไม่เปลี่ยน แต่รูปแบบการคิดค่าความเร็วเปลี่ยนไป:

• เพิ่ม Fast mode
• สร้างโทเค็นเร็วขึ้น 2.5 เท่า
• คิดค่าบริการ 2 เท่าของอัตรามาตรฐาน
• มาแทนระดับ Priority Processing เดิม

หากระบบของคุณใช้ Priority Processing อยู่ ให้ตรวจสอบการตั้งค่า deployment และรายการคิดเงินใหม่ทันที

แนวทางเลือกใช้งาน:

• ใช้ Sol มาตรฐาน เมื่อคุณต้องการ reasoning ระดับเรือธง แต่ latency ไม่ใช่ข้อจำกัดหลัก
• ใช้ Sol Fast สำหรับ flow แบบ interactive ที่ต้องตอบเร็วและยอมรับต้นทุนเพิ่มได้
• ประเมิน Terra หรือ Luna ก่อนส่งงานทั่วไปไป Sol เพื่อหลีกเลี่ยงการจ่ายเกินความจำเป็น

ทำไม OpenAI ถึงลดราคา

OpenAI ระบุว่าการลดราคาเกิดจากประสิทธิภาพของระบบ inference ที่ดีขึ้น ไม่ใช่เพียงการลดราคาเพื่อแข่งขัน โดยอ้างถึงปัจจัยหลัก 4 ข้อ:

• การปรับปรุง hardware routing ใน inference fleet
• ซอฟต์แวร์ inference สำหรับ production ที่ดีขึ้น
• อัลกอริทึม context caching ที่ฉลาดขึ้น
• เคอร์เนล production ที่ GPT-5.6 Sol ช่วยเขียนใหม่

OpenAI ระบุว่า Sol ช่วยเขียนเคอร์เนลบริการใหม่ ซึ่งลด end-to-end serving overhead ได้ 20% และเพิ่มประสิทธิภาพการสร้างโทเค็นมากกว่า 15%

แรงกดดันจากการแข่งขันก็มีผลเช่นกัน ตามรายงานของ VentureBeat ราคา list รวม input และ output ของ Luna อยู่ที่ $1.40 ต่อล้านโทเค็น ซึ่งต่ำกว่า:

• Gemini 3.5 Flash-Lite: $2.80
• Gemini 3.6 Flash: $9.00

อย่างไรก็ตาม อย่าใช้ราคาเป็นตัวตัดสินคุณภาพเพียงอย่างเดียว ให้เปรียบเทียบกับชุด eval ของคุณเอง

ผลกระทบต่อภาระงานของคุณ

การลดราคา Luna 80% มีผลต่อสถาปัตยกรรมมากกว่าการลดราคา Terra 20% โดยเฉพาะสำหรับ workload ที่ใช้โทเค็นจำนวนมาก

1. Agent loop มีต้นทุนต่ำลง

งานแบบ agent มักวนหลายขั้นตอน:

1. วางแผน
2. เรียกใช้เครื่องมือ
3. อ่านผลลัพธ์
4. สร้างคำตอบหรือ retry

Luna ที่ราคา $0.20 input และ $1.20 output ทำให้ loop ประเภทนี้เหมาะจะเป็นค่าเริ่มต้นมากขึ้น โดยเฉพาะงาน batch หรือ asynchronous agent

2. งาน routine ควรประเมิน Luna ใหม่

ลองย้าย workload เหล่านี้มา benchmark บน Luna:

• การจำแนกประเภทข้อความ
• การดึงข้อมูลแบบมีโครงสร้าง
• การสรุปเนื้อหา
• การติดแท็กข้อมูล
• การประมวลผลเอกสารแบบ batch

คุณภาพของ Luna ไม่ได้เปลี่ยน แต่ economics เปลี่ยนไปมาก งานที่มีค่าใช้จ่าย $100/วันบน Terra อาจมีค่าใช้จ่ายราว $11/วันบน Luna ภายใต้อัตราใหม่ หากจำนวนโทเค็นและรูปแบบ output ใกล้เคียงกัน

3. Terra ยังคงเป็น default ที่ควรปกป้อง

การเปรียบเทียบ Sol vs Terra vs Lunaแนะนำ Terra สำหรับงานทั่วไปที่ต้องการสมดุลระหว่างคุณภาพและต้นทุน คำแนะนำนี้ยังใช้ได้ แต่ต้นทุนลดลง 20%

4. Reasoning effort ยังสำคัญกว่าราคา list

GPT-5.6 มี reasoning effort หกระดับ ยิ่งตั้ง effort สูง โมเดลยิ่งสร้าง output token มากขึ้น ซึ่งเป็นทิศทางที่แพงกว่าในทุกระดับราคา

ก่อนเปลี่ยนโมเดล ให้ทำตามลำดับนี้:

1. ลด reasoning effort ให้เหมาะกับงาน
2. จำกัดความยาว output ด้วย max_output_tokens
3. วัด token usage จริง
4. ค่อยเปรียบเทียบ Luna, Terra และ Sol

วิธีตรวจสอบต้นทุนด้วยปริมาณการใช้งานจริง

อย่าอิงเพียงเปอร์เซ็นต์ส่วนลด ให้ทดสอบด้วยพรอมต์ production ที่เป็นตัวแทนของงานจริง

ขั้นตอนทดสอบ

1. ดึงตัวอย่าง request จาก production โดยลบข้อมูลอ่อนไหว
2. สร้างชุด eval ที่มี expected output หรือเกณฑ์ตรวจคุณภาพ
3. ส่ง request เดียวกันไปยัง gpt-5.6-luna, gpt-5.6-terra และ gpt-5.6-sol
4. บันทึก input token, output token, latency และผลการประเมิน
5. คำนวณต้นทุนต่อ request และต้นทุนรายวัน
6. กำหนด routing rule จากข้อมูลจริง

ตัวอย่างสูตรคำนวณต้นทุน:

cost =
  (input_tokens / 1_000_000 * input_price) +
  (output_tokens / 1_000_000 * output_price)

ตัวอย่างโค้ด JavaScript สำหรับเปรียบเทียบราคา:

const prices = {
  luna: { input: 0.2, output: 1.2 },
  terra: { input: 2, output: 12 },
  sol: { input: 5, output: 30 },
};

function estimateCost(model, inputTokens, outputTokens) {
  const price = prices[model];

  return (
    (inputTokens / 1_000_000) * price.input +
    (outputTokens / 1_000_000) * price.output
  );
}

console.log(estimateCost("luna", 10_000, 2_000));

Apidogช่วยให้ทำขั้นตอนนี้เร็วขึ้น: สร้าง request สำหรับ Chat Completion หนึ่งชุด ใช้ environment variable สลับ model ID แล้วรัน scenario เดิมกับทั้งสามโมเดล ตรวจสอบฟิลด์ usage ใน response เพื่อเก็บจำนวน input และ output token จริง

ตัวอย่างการใช้ตัวแปรสภาพแวดล้อมใน request body:

{
  "model": "{{model_id}}",
  "messages": [
    {
      "role": "user",
      "content": "{{prompt}}"
    }
  ]
}

กำหนด environment แยกกัน:

luna  -> model_id = gpt-5.6-luna
terra -> model_id = gpt-5.6-terra
sol   -> model_id = gpt-5.6-sol

หากคุณเพิ่งเริ่มเชื่อมต่อ GPT-5.6 กับแอป ดูคู่มือการใช้ GPT-5.6 APIสำหรับขั้นตอน authentication, model ID และรูปแบบ request คุณยังสามารถ mock endpoint ระหว่างรออนุมัติงบประมาณ แล้วสลับไปยัง API จริงโดยไม่ต้องเขียนชุดทดสอบใหม่

สร้าง model routing ให้เปลี่ยนได้ด้วย configuration

อย่าผูก model ID ไว้ใน business logic โดยตรง ให้แยก model routing เป็น configuration เพื่อให้ปรับตามราคาและผล eval ได้เร็ว

ตัวอย่าง:

const modelByTask = {
  classify: "gpt-5.6-luna",
  extract: "gpt-5.6-luna",
  summarize: "gpt-5.6-terra",
  codeReview: "gpt-5.6-terra",
  complexReasoning: "gpt-5.6-sol",
};

function getModel(taskType) {
  return modelByTask[taskType] ?? "gpt-5.6-terra";
}

สำหรับ production ให้เพิ่ม fallback ตามคุณภาพและความหน่วง:

function selectModel({ taskType, requiresFastResponse, complexity }) {
  if (requiresFastResponse && complexity === "high") {
    return "gpt-5.6-sol-fast";
  }

  if (complexity === "high") {
    return "gpt-5.6-sol";
  }

  if (taskType === "classify" || taskType === "extract") {
    return "gpt-5.6-luna";
  }

  return "gpt-5.6-terra";
}

ชื่อและรูปแบบการตั้งค่า Fast mode ให้ตรวจสอบกับเอกสาร API ล่าสุดก่อนนำไปใช้จริง

ภาพรวม: สงครามราคากำลังเปลี่ยนวิธีเลือกโมเดล

นี่คือการเคลื่อนไหวราคาครั้งสำคัญในกลุ่มโมเดลต้นทุนต่ำช่วงฤดูร้อนนี้:

• Google ปรับปรุง Gemini Flash ในเดือนกรกฎาคม
• Anthropic เปิดตัวClaude Opus 5 ในราคาครึ่งหนึ่งของ Fable 5
• OpenAI ลดราคา Luna ให้ต่ำกว่า Gemini Flash ทั้งสองตัวเลือกที่กล่าวถึงข้างต้น

สำหรับทีม API การเลือกโมเดลจึงไม่ควรเป็นการตัดสินใจปีละครั้ง ให้ปฏิบัติกับ model routing เป็น infrastructure:

• เก็บ model ID ใน configuration
• รักษาชุด eval อย่างต่อเนื่อง
• บันทึก token usage และ latency
• ทบทวนต้นทุนทุกครั้งที่ผู้ให้บริการเปลี่ยนราคา
• deploy routing change ผ่าน feature flag หรือ canary rollout

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

ราคา API ใหม่ของ GPT-5.6 คืออะไร?

ณ วันที่ 30 กรกฎาคม 2026:

• Luna: $0.20 ต่อล้านโทเค็นขาเข้า และ $1.20 ต่อล้านโทเค็นขาออก
• Terra: $2 ต่อล้านโทเค็นขาเข้า และ $12 ต่อล้านโทเค็นขาออก
• Sol: $5 ต่อล้านโทเค็นขาเข้า และ $30 ต่อล้านโทเค็นขาออก

Sol ยังมี Fast mode ที่ราคา 2 เท่าของอัตรามาตรฐานเพื่อความเร็วเพิ่มขึ้น 2.5 เท่า

GPT-5.6 Sol ลดราคาหรือไม่?

ไม่ ราคา standard ของ Sol ไม่เปลี่ยนแปลง การเปลี่ยนแปลงคือ Fast mode ใหม่ที่มาแทน Priority Processing เดิม

GPT-5.6 Luna ถูกกว่า Gemini Flash แล้วใช่ไหม?

ตามราคา list ใช่ Luna มีอัตรารวม input และ output ที่ $1.40 ต่อล้านโทเค็น เทียบกับ $2.80 สำหรับ Gemini 3.5 Flash-Lite และ $9 สำหรับ Gemini 3.6 Flash

แต่ราคาถูกกว่าไม่ได้หมายความว่าคุณภาพเหมาะกับทุก workload ควรทดสอบกับ eval suite ของคุณก่อนย้าย traffic หากต้องการเริ่มจากตัวเลือกที่ไม่มีค่าใช้จ่าย ดูวิธีใช้ GPT-5.6 ฟรี

การลดราคามีผลอัตโนมัติหรือไม่?

ใช่ อัตราใหม่มีผลกับ API ระดับมาตรฐานตั้งแต่วันที่ 30 กรกฎาคม 2026 โดยไม่ต้องแก้โค้ด การดำเนินการจำเป็นสำหรับทีมที่ใช้ Priority Processing บน Sol เนื่องจากถูกแทนที่ด้วย Fast mode

สิ่งที่ควรทำในสัปดาห์นี้

1. อัปเดตโมเดลต้นทุนด้วยราคา Luna, Terra และ Sol ใหม่
2. ระบุ workload ที่ใช้ Terra หรือ Sol แต่สามารถทดลองบน Luna ได้
3. รัน eval เดียวกันกับทั้งสามโมเดล
4. ตรวจสอบ token usage จริง ไม่ใช่เฉพาะราคา list
5. ย้ายการตั้งค่า Priority Processing ของ Sol ไปยัง Fast mode หากจำเป็น
6. ทำให้ model ID เป็น configuration เพื่อรองรับการเปลี่ยนราคาในอนาคต

เริ่มด้วย scenario เดียวในApidog, ทดสอบสาม model ID และใช้ข้อมูล usage จาก response เพื่อวัดว่าการลดราคานี้ช่วยลดค่าใช้จ่ายของระบบคุณได้เท่าไร