วิธีใช้ gpt-image-2.5 API (Flare และ Sunburst) ด้วย curl, Python และ Node

OpenAI ได้เปิดตัว ChatGPT Images 2.5 เมื่อวันที่ 8 กันยายน 2026 พร้อมด้วยโมเดล API ใหม่สองรุ่น: gpt-image-2.5-flare และ gpt-image-2.5-sunburst ทั้งสองโมเดลใช้เอนด์พอยต์เดียวกับ gpt-image-2 ดังนั้น หากคุณทำตามคู่มือ API ของ gpt-image-2 ของเรา โค้ดส่วนใหญ่ของคุณจะยังคงใช้งานได้ เพียงแค่สลับ ID โมเดล สิ่งที่เปลี่ยนไปคือระดับคุณภาพและวิธีที่ Responses API ให้คุณเลือกโมเดลสำหรับการเรียกใช้เครื่องมือแต่ละครั้ง

คู่มือนี้ครอบคลุมเฉพาะเส้นทางสำหรับนักพัฒนาเท่านั้น: การสร้างภาพ, การแก้ไขแบบหลายส่วนด้วยภาพอ้างอิงและมาสก์, เครื่องมือ Responses API, การสตรีมมิ่ง, และการอ่าน usage เพื่อคำนวณค่าใช้จ่ายจริง สำหรับความหมายของการเปิดตัวนี้สำหรับผู้ใช้ ChatGPT โปรดอ่านภาพรวม ChatGPT Images 2.5 ของเรา; โพสต์เปิดตัวของ OpenAI มีกรอบของผลิตภัณฑ์ ตัวเลขทุกตัวด้านล่างมาจากเอกสารของ OpenAI, หน้าการกำหนดราคา หรือเครื่องคำนวณ ณ วันที่ 9 กันยายน 2026

gpt-image-2.5 API โดยสรุป

อัตราต่อโทเค็นตรงกับ gpt-image-2; ค่าใช้จ่ายต่อภาพยังคงเปลี่ยนแปลงเนื่องจากจำนวนโทเค็นต่อระดับคุณภาพมีการเปลี่ยนแปลง

ข้อกำหนดเบื้องต้น

• บัญชีนักพัฒนา OpenAI ในระดับการใช้งานแบบชำระเงิน เอนด์พอยต์รูปภาพต้องใช้ Tier 1 ขึ้นไป ซึ่งหมายถึงการเพิ่มวิธีการชำระเงิน; การสมัครสมาชิก ChatGPT ไม่นับรวม คำแนะนำเกี่ยวกับ OpenAI API key ของเราครอบคลุมคีย์ที่จำกัดขอบเขตโปรเจกต์
• SDK อย่างเป็นทางการของ openai สำหรับ Python หรือ Node
• วิธีดูตัวอย่างการตอบกลับรูปภาพ curl พิมพ์ base64 ซึ่งยากต่อการวนซ้ำ; Apidog แสดงผลรูปภาพที่ถอดรหัสแล้วแบบอินไลน์ และส่วนสุดท้ายจะย้ายขั้นตอนการทำงานไปที่นั่น

ส่งออกคีย์เพียงครั้งเดียว:

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

สร้างภาพด้วย curl

ใช้ Flare ก่อน; หน้าโมเดลของ OpenAI เรียกมันว่า "ตัวเลือกเริ่มต้นสำหรับแอปพลิเคชันส่วนใหญ่"

curl https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.5-flare",
    "prompt": "Product photo of a matte black mechanical keyboard, studio lighting, no text",
    "size": "1536x1024",
    "quality": "medium",
    "output_format": "webp",
    "background": "transparent"
  }'

การตอบกลับจะประกอบด้วยอาร์เรย์ data ที่มี b64_json หนึ่งรายการต่อภาพ พร้อมด้วยออบเจกต์ usage ที่มี input_tokens และ output_tokens เก็บ usage ไว้; เป็นสัญญาณค่าใช้จ่ายที่แม่นยำเพียงอย่างเดียวที่คุณจะได้รับ หมายเหตุพารามิเตอร์จากคู่มือการสร้างภาพ: output_format มีค่าเริ่มต้นเป็น png และ OpenAI ระบุว่า "การใช้ jpeg เร็วกว่า png"; output_compression (0-100) ใช้ได้กับ jpeg และ webp เท่านั้น; background: "transparent" จะล้มเหลวบน jpeg

Python: สร้างแล้วแก้ไขด้วยภาพอ้างอิง

การเรียก SDK สะท้อนถึงเนื้อหาของ curl ถอดรหัส b64_json และเขียนไบต์

import base64
from openai import OpenAI

client = OpenAI()

gen = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="Clean API analytics dashboard mockup, dark theme, latency chart top right",
    size="1536x1024",
    quality="high",
    output_format="png",
)
open("dashboard.png", "wb").write(base64.b64decode(gen.data[0].b64_json))
print(gen.usage.output_tokens, "output tokens")

การแก้ไขคือสิ่งที่ทำให้โมเดล 2.5 คุ้มค่า โพสต์เปิดตัวระบุว่าพวกมัน "เก่งกว่าในการแก้ไขเฉพาะสิ่งที่คุณร้องขอ ในขณะที่ยังคงรายละเอียดส่วนที่เหลือไว้เหมือนเดิม" และ OpenAI วางตำแหน่ง Sunburst สำหรับ "การควบคุมที่เข้มงวดมากขึ้นในการแก้ไข" เอนด์พอยต์การแก้ไขเป็นแบบหลายส่วน: ภาพอ้างอิง, มาสก์เสริม, และพร้อมต์ ส่วนที่มาสก์โปร่งใส โมเดลจะวาดใหม่; ส่วนอื่นๆ จะคงต้นฉบับไว้

edit = client.images.edit(
    model="gpt-image-2.5-sunburst",
    image=open("dashboard.png", "rb"),
    mask=open("chart-area-mask.png", "rb"),
    prompt="Replace the latency chart with a bar chart of error rates per endpoint; keep everything else",
    size="1536x1024",
    quality="high",
)
open("dashboard-v2.png", "wb").write(base64.b64decode(edit.data[0].b64_json))
print(edit.usage.input_tokens, "input tokens (includes the reference image)")

หากไม่มี mask โมเดลจะตัดสินใจว่าจะเปลี่ยนอะไรจากพร้อมต์เพียงอย่างเดียว ภาพอ้างอิงจะถูกเรียกเก็บเงินเป็นโทเค็นอินพุตภาพในราคา 8 ดอลลาร์ต่อ 1 ล้านโทเค็น; OpenAI ไม่ได้เผยแพร่จำนวนโทเค็นอินพุตต่อภาพ ดังนั้นให้อ่าน usage.input_tokens

Node และ TypeScript: เขียน b64_json ลงดิสก์

import fs from "node:fs/promises";
import OpenAI from "openai";

const client = new OpenAI();

const res = await client.images.generate({
  model: "gpt-image-2.5-flare",
  prompt: "Hero image for API docs: floating JSON cards over a teal gradient, no text",
  size: "1536x1024",
  quality: "medium",
  output_format: "jpeg",
  output_compression: 80,
});

const b64 = res.data?.[0]?.b64_json;
if (!b64) throw new Error("no image returned");
await fs.writeFile("hero.jpg", Buffer.from(b64, "base64"));

ปักหมุด gpt-image-2.5-flare-2026-09-08 ในเวอร์ชันที่ใช้งานจริงเพื่อรักษาเสถียรภาพของเอาต์พุตในขณะที่ชื่อแทนมีการเปลี่ยนแปลง

Responses API: การสร้างภาพเป็นเครื่องมือ

ที่นี่ โมเดลหลักจะอ่านพร้อมต์ของคุณ, ปรับปรุงแก้ไข, และเรียกใช้เครื่องมือ image_generation คุณเลือกโมเดลรูปภาพโดยการตั้งค่า model ภายในนิยามเครื่องมือ; model ระดับบนสุดต้องเป็นโมเดลหลัก และเอกสารเครื่องมือของ OpenAI ใช้ gpt-6-astra คู่มือ Responses API ของเราครอบคลุมรูปแบบการร้องขอ ฟิลด์ action รับค่า auto (ค่าเริ่มต้น), generate, หรือ edit; ตั้งค่าเป็น edit เมื่อคุณส่งภาพอ้างอิงและต้องการให้ภาพนั้นถูกแก้ไข ไม่ใช่ถูกตีความใหม่

import base64

with open("product.png", "rb") as f:
    ref = base64.b64encode(f.read()).decode()

first = client.responses.create(
    model="gpt-6-astra",
    input=[{"role": "user", "content": [
        {"type": "input_text", "text": "Put this bottle on a white marble surface with soft daylight"},
        {"type": "input_image", "image_url": f"data:image/png;base64,{ref}"},
    ]}],
    tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst", "action": "edit"}],
)
calls = [o for o in first.output if o.type == "image_generation_call"]
open("bottle-marble.png", "wb").write(base64.b64decode(calls[0].result))

second = client.responses.create(
    model="gpt-6-astra",
    previous_response_id=first.id,
    input="Same scene, but add a second bottle behind it, slightly out of focus",
    tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst", "action": "edit"}],
)

การติดตาม previous_response_id จะเก็บภาพแรกไว้ในบริบท ดังนั้น "ฉากเดียวกัน" จึงสามารถแก้ไขได้โดยไม่ต้องอัปโหลดไฟล์ซ้ำ โทเค็นของโมเดลหลักจะถูกเรียกเก็บเงินเพิ่มเติมจากโทเค็นรูปภาพ และการเขียนพร้อมต์ใหม่หมายความว่าคุณไม่สามารถสร้างเอาต์พุตจากข้อความพร้อมต์เพียงอย่างเดียวได้

การสตรีมภาพบางส่วน

ทั้งสอง API ยอมรับ partial_images (0 ถึง 3) แต่ละส่วนมีค่าใช้จ่ายเพิ่ม 100 โทเค็นเอาต์พุต ดังนั้นสามส่วนจะเพิ่ม 300 โทเค็น หรือ 0.009 ดอลลาร์ต่อภาพ คุ้มค่าสำหรับ UI ที่แสดงความคืบหน้า; สิ้นเปลืองในงานแบบแบตช์

stream = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="Isometric illustration of an API gateway routing requests to three services",
    size="1024x1024",
    quality="medium",
    stream=True,
    partial_images=2,
)
for event in stream:
    if event.type.endswith("partial_image"):
        open(f"gateway-partial-{event.partial_image_index}.png", "wb").write(
            base64.b64decode(event.b64_json))
    elif event.type.endswith("completed"):
        open("gateway.png", "wb").write(base64.b64decode(event.b64_json))

สตริงประเภทเหตุการณ์ที่แน่นอนอยู่ในคู่มือการสร้างภาพ; การตรวจสอบส่วนท้ายช่วยให้ลูปทำงานได้กับทั้งสองรูปแบบ API หากต้องการตรวจสอบเหตุการณ์ที่สตรีมจากภายนอกโค้ด โปรดดูคู่มือของเราเกี่ยวกับการทดสอบการตอบกลับ SSE จาก AI API

อ่านการใช้งานและเปลี่ยนโทเค็นเป็นดอลลาร์

คำเตือนของ OpenAI เอง: "อัตราโทเค็นที่เท่ากันไม่ได้หมายความว่าค่าใช้จ่ายต่อภาพจะเท่ากัน: การใช้โทเค็นอาจแตกต่างกันไปตามโมเดลและการตั้งค่าคุณภาพ" เครื่องคำนวณในคู่มือการสร้างภาพให้ประมาณการเหล่านี้สำหรับโทเค็นเอาต์พุตภาพเพียงอย่างเดียว ที่อัตรา 30 ดอลลาร์ต่อ 1 ล้านโทเค็นบนหน้าการกำหนดราคา:

โปรดสังเกตการเปลี่ยนชื่อ high บน 2.5 ใช้ 1,756 โทเค็น ซึ่งเป็นงบ medium เดิมบน gpt-image-2; max ใช้ 7,024 โทเค็น ซึ่งเป็นงบ high เดิม รักษาระดับ quality: "high" ในการโยกย้าย และภาพแต่ละภาพจะมีราคาถูกลงประมาณ 4 เท่าด้วยงบ medium เดิม; สำหรับงบ high เดิม ให้เปลี่ยนไปใช้ max การเปรียบเทียบ Flare vs Sunburst vs gpt-image-2 ของเราจะคำนวณค่าใช้จ่ายรายเดือนทั้งหมด

ตัวเลขในเครื่องคำนวณเป็นค่าประมาณ ค่าใช้จ่ายจริงมาจากการตอบกลับ:

OUTPUT_RATE = 30 / 1_000_000  # dollars per image output token
usd = gen.usage.output_tokens * OUTPUT_RATE
print(f"{gen.usage.output_tokens} tokens = ${usd:.4f}")

บันทึกข้อมูลต่อคำขอ; ตามข้อมูลของ OpenAI ขนาดที่ไม่ใช่สี่เหลี่ยมจัตุรัสที่ใหญ่กว่าอาจสร้างโทเค็นน้อยกว่าขนาดสี่เหลี่ยมจัตุรัสที่เล็กกว่า คำถามที่ยังไม่มีคำตอบ: แท็บ Batch ในหน้าการกำหนดราคาระบุเฉพาะ gpt-image-2 เท่านั้น ดังนั้นจึงถือว่าการรองรับ Batch API สำหรับ 2.5 ยังไม่ได้รับการยืนยัน

ข้อผิดพลาด, ข้อจำกัดอัตรา, และการหมดเวลา

• 429 ข้อจำกัดอัตรา ถอยกลับด้วย jitter และปฏิบัติตาม Retry-After หน้าโมเดล 2.5 ไม่ได้เผยแพร่ข้อจำกัดต่อระดับ สำหรับอ้างอิง gpt-image-2 ทำงานใน Tier 1 ที่ 5 ภาพต่อนาทีและ 100k TPM โดยปรับขนาดเป็น Tier 5 ที่ 250 IPM และ 8M TPM
• insufficient_quota ไม่มีเครดิตหรือยังอยู่ในระดับฟรี เพิ่มการเรียกเก็บเงิน; อย่าลองใหม่
• การปฏิเสธการดูแล พร้อมต์หรือภาพอ้างอิงถูกกรอง แก้ไขคำใหม่แทนการลองใหม่; moderation: "low" ช่วยผ่อนปรนเกณฑ์
• การหมดเวลา เอกสารของ OpenAI ระบุว่า "พร้อมต์ที่ซับซ้อนอาจใช้เวลาประมวลผลสูงสุด 2 นาที" ตั้งค่าการหมดเวลาของไคลเอนต์ให้สูงกว่านั้น; Sunburst ใช้เวลานานกว่า Flare ตามการออกแบบ

ทดสอบ Flare และ Sunburst ควบคู่กันใน Apidog

การวนซ้ำพร้อมต์ภาพในเทอร์มินัลนั้นช้าเพราะคุณไม่สามารถเห็นผลลัพธ์ได้ และค่า quality ที่ผิดพลาดจะทำให้เสียเงินจริงในการส่งแต่ละครั้ง Apidog เป็นไคลเอนต์ API และแพลตฟอร์มการทดสอบ: มันส่งการเรียกและตรวจสอบการตอบกลับ; เซิร์ฟเวอร์ของ OpenAI ทำการเรนเดอร์

1. จัดเก็บคีย์เพียงครั้งเดียว เพิ่ม OPENAI_API_KEY เป็นตัวแปรสภาพแวดล้อมและอ้างอิงเป็น Bearer {{OPENAI_API_KEY}} ในส่วนหัว Authorization; คีย์จะไม่ถูกบันทึกในคำขอที่บันทึกไว้
2. สองสภาพแวดล้อม, หนึ่งคำขอ สร้างสภาพแวดล้อมชื่อ flare และ sunburst โดยแต่ละสภาพแวดล้อมมีตัวแปร MODEL และตั้งค่า "model": "{{MODEL}}" ในส่วนเนื้อหา สลับ, ส่งใหม่, และเปรียบเทียบรูปภาพและ usage แบบเคียงข้างกัน สำหรับการแก้ไข ให้ใช้เนื้อหา form-data ที่มี image และ mask เป็นฟิลด์ไฟล์
3. ถอดรหัส b64_json ในส่วนหลังการประมวลผล สคริปต์สั้นๆ จะดึง data[0].b64_json, ถอดรหัส, และบันทึกไฟล์ เพื่อให้ทุกครั้งที่ส่งจะได้ภาพที่ดูได้ถัดจาก JSON ดิบ
4. ยืนยันค่าใช้จ่าย แล้วตั้งเวลา ยืนยันว่า usage.output_tokens อยู่ภายใต้งบประมาณ เช่น 2,000 สำหรับการเรนเดอร์ 1536x1024 แบบ high และรันคำขอเป็นการทดสอบ regression แบบตั้งเวลา หากมีคนปรับคุณภาพเป็น max หรือสแนปช็อตเปลี่ยนจำนวนโทเค็น การทดสอบจะล้มเหลวก่อนที่จะมีใบแจ้งหนี้

ดาวน์โหลด Apidog, ชี้ไปที่คีย์ OpenAI ของคุณ, แล้วคุณจะมีคลังพร้อมต์ที่ใช้ร่วมกันพร้อมการป้องกันค่าใช้จ่าย

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

ฉันต้องเปลี่ยนโค้ด gpt-image-2 เพื่อใช้ 2.5 หรือไม่? สลับ ID โมเดลและตรวจสอบ quality อีกครั้ง เอนด์พอยต์, การยืนยันตัวตน, และรูปแบบการตอบกลับไม่เปลี่ยนแปลง แต่ high ตอนนี้แมปกับงบประมาณโทเค็นที่น้อยลง คู่มือ API ของ gpt-image-2 ยังคงครอบคลุมโมเดลรุ่นเก่ากว่า

Flare หรือ Sunburst สำหรับ API? เริ่มต้นด้วย Flare OpenAI วางตำแหน่งให้เป็นค่าเริ่มต้นด้วย "เวลาแฝงลดลง 50%" เมื่อเทียบกับ gpt-image-2 ในราคาต่อโทเค็นเดียวกัน เปลี่ยนไปใช้ Sunburst เมื่อความแม่นยำในการแก้ไขมีความสำคัญมากกว่าความเร็ว เช่น ภาพผลิตภัณฑ์ที่สร้างจากภาพอ้างอิง ทั้งสองใช้จำนวนโทเค็นในเครื่องคำนวณเดียวกัน ดังนั้นการแลกเปลี่ยนคือเวลา ไม่ใช่เงิน

ฉันสามารถใช้โมเดลเหล่านี้ในการเติมข้อความแชทได้หรือไม่? ไม่ได้ การสร้างภาพมีอยู่ใน Image API และเครื่องมือ image_generation ของ Responses API การเติมข้อความแชทไม่ได้เปิดเผยคุณสมบัตินี้

มีวิธีลองใช้ 2.5 ผ่าน API ฟรีหรือไม่? ไม่มีระดับ API ฟรีตลอดไป และเอนด์พอยต์ภาพต้องใช้ Tier 1 เส้นทางที่ถูกที่สุดคือ quality: "low" ที่ 196 โทเค็น ประมาณ $0.006 ต่อภาพขนาด 1024x1024 แอปพลิเคชันสำหรับผู้บริโภคเป็นอีกเรื่องหนึ่ง; ดู วิธีใช้ ChatGPT Images 2.5 ฟรี

จะไปต่อที่ไหน

เริ่มต้นด้วยการเรียก curl, ยืนยัน usage.output_tokens เทียบกับตารางเครื่องคำนวณ, จากนั้นย้ายคำขอไปยังไคลเอนต์ที่คุณสามารถเห็นภาพได้ บทความของ Simon Willison แสดงให้เห็นว่า Sunburst รักษาแผนภูมิให้คงเดิมในขณะที่เพิ่มวัตถุ; ทดสอบพฤติกรรมการแก้ไขนั้นกับภาพอ้างอิงของคุณเองก่อนที่จะนำไปใช้จริง