ImageGen with OpenAI API: สร้างและแก้ไขภาพด้วย Python และ Node.js

• 1. ImageGen คืออะไร
• 2. เลือก API ให้เหมาะกับงาน
• 3. เลือกโมเดลสร้างภาพ
• 4. เตรียม API key และ SDK
• 5. สร้างภาพแรกด้วย Python
  • ทำไมต้องถอดรหัส Base64
• 6. สร้างภาพด้วย Node.js
• 7. แก้ไขภาพและสร้างมาสคอตพื้นหลังโปร่งใส
• 8. สร้างภาพแล้วแก้ไขต่อด้วย Responses API
• 9. พารามิเตอร์ที่ใช้บ่อย
• 10. เขียน prompt ให้ตรวจผลได้
• 11. ประเมินค่าใช้จ่าย
• 12. เชื่อมต่อกับเว็บแอป
• 13. ปัญหาที่พบบ่อย
• 14. Workshop สำหรับชั้นเรียน
• เอกสารอ้างอิง

#1. ImageGen คืออะไร

ImageGen ในบทความนี้หมายถึงงานสร้างภาพด้วย AI ผ่าน OpenAI API โดยส่งคำอธิบายภาพหรือภาพต้นฉบับให้โมเดลตระกูล GPT Image ประมวลผล แล้วนำข้อมูลภาพที่ได้ไปบันทึกหรือแสดงในแอปพลิเคชัน

ชื่อที่ส่งในพารามิเตอร์ model ต้องเป็นรหัสโมเดลที่รองรับ เช่น gpt-image-2.5-flare คำว่า ImageGen เป็นคำเรียกความสามารถในบทความนี้

ตัวอย่างการประยุกต์ใช้ ได้แก่ ภาพประกอบบทเรียน หน้าปกบทความ ภาพสินค้า มาสคอต และระบบที่ให้ผู้ใช้ปรับภาพผ่านบทสนทนา [1]

#2. เลือก API ให้เหมาะกับงาน

Image API ใช้โมเดลสร้างภาพโดยตรง ส่วน Responses API ใช้โมเดลหลักจัดการบทสนทนาและเรียกเครื่องมือสร้างภาพ จึงต้องแยก โมเดลหลัก ออกจาก โมเดลของเครื่องมือ ให้ชัดเจน [1][5]

#3. เลือกโมเดลสร้างภาพ

เอกสารทางการ ณ วันที่ตรวจสอบแนะนำ GPT Image 2.5 สำหรับการเชื่อมต่อใหม่ โดยแบ่งแนวทางเลือกดังนี้ [1][2][3]

สำหรับงานทดลองที่ต้องบันทึกเวอร์ชัน สามารถใช้ snapshot เช่น gpt-image-2.5-flare-2026-09-08 แล้วเก็บชื่อโมเดลพร้อม prompt และค่าพารามิเตอร์ไว้ในบันทึกการทดลอง การตรึง snapshot ช่วยระบุเวอร์ชันที่ใช้ แต่ไม่รับประกันว่าภาพจากการเรียกซ้ำจะเหมือนกันทุกพิกเซล

#4. เตรียม API key และ SDK

สร้าง API key ที่ OpenAI Platform และเก็บในตัวแปรสภาพแวดล้อม OPENAI_API_KEY SDK จะอ่านค่านี้ให้อัตโนมัติ [6]

macOS / Linux:

export OPENAI_API_KEY="YOUR_API_KEY"

Windows PowerShell — ใช้กับหน้าต่างปัจจุบัน:

$env:OPENAI_API_KEY="YOUR_API_KEY"

เลือกติดตั้ง SDK ตามภาษาที่ใช้:

python -m pip install --upgrade openai

npm install openai

ก่อนทดลองให้ตรวจสอบสิทธิ์โมเดลและสถานะการชำระเงินของ API ในโครงการ บางบัญชีอาจต้องยืนยันองค์กรก่อนใช้ GPT Image [1]

เก็บ key ฝั่งเซิร์ฟเวอร์หรือในระบบจัดการ secrets หากใช้ .env ให้เพิ่มไฟล์ดังกล่าวใน .gitignore และหลีกเลี่ยงการฝัง key ใน JavaScript ที่ส่งไปยังเบราว์เซอร์ [9]

#5. สร้างภาพแรกด้วย Python

สร้างไฟล์ generate_image.py:

import base64
import os
from pathlib import Path

from openai import OpenAI


def main():
    if not os.getenv("OPENAI_API_KEY"):
        raise SystemExit("Set OPENAI_API_KEY before running this script.")

    # Disable automatic retries in this teaching example.
    # Add a deliberate retry policy when integrating into an application.
    client = OpenAI(timeout=180.0, max_retries=0)

    image_response = client.images.generate(
        model="gpt-image-2.5-flare",
        prompt=(
            "Create a bright editorial illustration for a programming blog. "
            "Show a cute orange cat beside a laptop, with small floating "
            "image cards. Use a clean mint and cream background. "
            "Leave generous empty space in the upper third for a title "
            "that will be added later. No lettering, no watermark."
        ),
        n=1,
        size="1536x1024",
        quality="medium",
        output_format="png",
        background="opaque",
    )

    images = image_response.data or []
    if not images or not images[0].b64_json:
        raise RuntimeError("The response did not contain image data.")

    destination = Path("output/blog-cover.png")
    destination.parent.mkdir(parents=True, exist_ok=True)
    destination.write_bytes(
        base64.b64decode(images[0].b64_json, validate=True)
    )
    print(f"Saved: {destination.resolve()}")


if __name__ == "__main__":
    main()

รันด้วยคำสั่ง:

python generate_image.py

เมื่อ API สำเร็จ โปรแกรมจะได้ไฟล์ output/blog-cover.png ขนาดที่ร้องขอคือ 1536 × 1024 ซึ่งเป็นอัตราส่วน 3:2 หากต้องการตัวอย่าง 16:9 สามารถใช้ 1536x864 ได้ตามข้อจำกัดของโมเดลปัจจุบัน [4]

#ทำไมต้องถอดรหัส Base64

GPT Image ส่งข้อมูลภาพกลับมาในฟิลด์ b64_json จึงต้องถอดรหัสเป็น bytes ก่อนเขียนไฟล์ ไม่ควรเขียนข้อความ Base64 ลงไฟล์ .png โดยตรง และไม่ต้องส่ง response_format="url" ซึ่งเป็นพารามิเตอร์เก่าสำหรับโมเดลภาพที่เลิกใช้งานแล้ว [4]

#6. สร้างภาพด้วย Node.js

สร้างไฟล์ generate-image.mjs:

import OpenAI from "openai";
import { mkdir, writeFile } from "node:fs/promises";

if (!process.env.OPENAI_API_KEY) {
  throw new Error("Set OPENAI_API_KEY before running this script.");
}

const client = new OpenAI({ timeout: 180_000, maxRetries: 0 });

const imageResponse = await client.images.generate({
  model: "gpt-image-2.5-flare",
  prompt: [
    "Create a bright illustration for a software engineering lesson.",
    "A cute orange cat sits beside a laptop and three colorful image cards.",
    "Use soft mint and cream colors, with a spacious composition.",
    "No lettering, no watermark.",
  ].join(" "),
  n: 1,
  size: "1536x1024",
  quality: "medium",
  output_format: "png",
});

const encoded = imageResponse.data?.[0]?.b64_json;
if (!encoded) {
  throw new Error("The response did not contain image data.");
}

await mkdir("output", { recursive: true });
await writeFile("output/node-cover.png", Buffer.from(encoded, "base64"));
console.log("Saved: output/node-cover.png");

รันด้วยคำสั่ง:

node generate-image.mjs

ตัวอย่างนี้ทำงานใน Node.js ฝั่งเซิร์ฟเวอร์ รูปแบบ request และผลลัพธ์สอดคล้องกับ Image API เช่นเดียวกับ Python [4][6]

#7. แก้ไขภาพและสร้างมาสคอตพื้นหลังโปร่งใส

ใช้ภาพ output/blog-cover.png จากตัวอย่าง Python เป็นอินพุต แล้วขอแยกแมวออกมาเป็นภาพมาสคอต สร้างไฟล์ edit_image.py:

import base64
from pathlib import Path

from openai import OpenAI


client = OpenAI(timeout=180.0, max_retries=0)
source = Path("output/blog-cover.png")
if not source.is_file():
    raise SystemExit("Run generate_image.py first.")

with source.open("rb") as source_file:
    edited = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=source_file,
        prompt=(
            "Edit this image to isolate only the orange cat as a mascot. "
            "Preserve its fur colors, face, and illustration style. "
            "Remove the laptop, cards, and scenery. Center the whole cat "
            "with comfortable margins on a transparent background. "
            "No text, no watermark."
        ),
        size="1024x1024",
        quality="high",
        output_format="png",
        background="transparent",
    )

images = edited.data or []
if not images or not images[0].b64_json:
    raise RuntimeError("The response did not contain an edited image.")

destination = Path("output/cat-mascot.png")
destination.write_bytes(base64.b64decode(images[0].b64_json, validate=True))
print(f"Saved: {destination.resolve()}")

python edit_image.py

สำหรับ GPT Image 2.5 การขอพื้นหลังโปร่งใสใช้ background="transparent" คู่กับ output_format="png" หรือ "webp" ไฟล์ JPEG ไม่รองรับช่อง alpha [7]

คำสั่งให้รักษารายละเอียดเดิมเป็นข้อกำหนดใน prompt จึงยังต้องตรวจภาพจริง โดยเฉพาะใบหน้า สี และส่วนประกอบที่ต้องคงเดิม

#8. สร้างภาพแล้วแก้ไขต่อด้วย Responses API

ตัวอย่างต่อไปนี้แสดงการสร้างภาพในรอบแรก แล้วอ้างอิง previous_response_id เพื่อแก้ไขรอบถัดไป เหมาะกับแนวทางสร้างผู้ช่วยออกแบบภาพ [5]

สร้างไฟล์ conversation_images.py:

import base64
from pathlib import Path

from openai import OpenAI


client = OpenAI(timeout=180.0, max_retries=0)
output_dir = Path("output")
output_dir.mkdir(parents=True, exist_ok=True)


def save_generated_image(response, filename):
    for item in response.output:
        if item.type == "image_generation_call" and item.result:
            destination = output_dir / filename
            destination.write_bytes(
                base64.b64decode(item.result, validate=True)
            )
            print(f"Saved: {destination.resolve()}")
            return
    raise RuntimeError("No completed image generation result was returned.")


first = client.responses.create(
    model="gpt-6-astra",
    input=(
        "Draw a cute orange cat beside a laptop for a programming blog. "
        "Use a bright mint background and no lettering."
    ),
    tools=[{
        "type": "image_generation",
        "model": "gpt-image-2.5-flare",
        "action": "generate",
        "size": "1536x1024",
        "quality": "medium",
        "output_format": "png",
    }],
    tool_choice={"type": "image_generation"},
)
save_generated_image(first, "conversation-v1.png")

second = client.responses.create(
    model="gpt-6-astra",
    previous_response_id=first.id,
    input=(
        "Edit the previous image: change only the background to pale blue. "
        "Preserve the cat, laptop, and composition."
    ),
    tools=[{
        "type": "image_generation",
        "model": "gpt-image-2.5-sunburst",
        "action": "edit",
        "output_format": "png",
    }],
    tool_choice={"type": "image_generation"},
)
save_generated_image(second, "conversation-v2.png")

python conversation_images.py

จุดที่ต้องสังเกตคือ model ชั้นบนเป็นโมเดลหลัก ส่วน tools[].model เป็นโมเดลภาพ และข้อมูลภาพอยู่ใน response.output ชนิด image_generation_call ฟิลด์ result ไม่ใช่ response.output_text [5]

ตัวอย่างนี้ต้องใช้โมเดลหลักและโมเดลภาพที่บัญชีเข้าถึงได้ หากเลือกโมเดลหลักตัวอื่น ให้ตรวจว่ารองรับเครื่องมือสร้างภาพก่อน

#9. พารามิเตอร์ที่ใช้บ่อย

GPT Image 2.5 รองรับคุณภาพ low, medium, high, xhigh, max และ auto ส่วนตัวอย่างในบทความใช้ขนาดมาตรฐานเป็นหลัก หากกำหนดขนาดเองต้องตรวจข้อจำกัดด้านจำนวนพิกเซล ความยาวขอบ และอัตราส่วนจากเอกสารล่าสุด [4]

n ในตารางเป็นพารามิเตอร์ของ Image API ไม่ควรย้ายพารามิเตอร์ทั้งหมดไปใส่ในเครื่องมือของ Responses API โดยตรงโดยไม่ตรวจ schema [4][5]

#10. เขียน prompt ให้ตรวจผลได้

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

ตัวอย่าง prompt ภาษาไทยที่ผู้เขียนออกแบบสำหรับทดลอง:

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

หากต้องการให้อินโฟกราฟิกมีข้อความภาษาไทย ให้กำหนดข้อความสั้นและตรวจตัวสะกดทุกจุด งานที่ต้องการตำแหน่งและตัวอักษรแน่นอนสามารถสร้างภาพประกอบก่อน แล้วจัดวางข้อความด้วยเครื่องมือออกแบบในขั้นตอนถัดไป โมเดลยังมีข้อจำกัดด้านข้อความและการจัดองค์ประกอบอย่างแม่นยำ [1]

#11. ประเมินค่าใช้จ่าย

ค่าใช้จ่ายสัมพันธ์กับโทเคนข้อความเข้า ภาพเข้า และภาพออก จึงไม่ควรสมมติว่าทุกภาพมีราคาเท่ากัน ตารางนี้แสดงอัตรา Standard ที่หน้าโมเดลระบุ ณ วันที่ตรวจสอบ [2][3]

ตัวอย่างคำนวณสมมติ: หากคำขอหนึ่งใช้ข้อความเข้า 1,000 โทเคน ภาพออก 2,000 โทเคน และไม่มีภาพเข้า:

ค่าข้อความเข้า = 1,000 / 1,000,000 × 5 = 0.005 USD
ค่าภาพออก    = 2,000 / 1,000,000 × 30 = 0.060 USD
รวม          = 0.065 USD

ตัวเลขจำนวนโทเคนข้างต้นเป็นสมมติฐานเพื่อสาธิตสูตร ไม่ใช่ราคาหรือการใช้โทเคนจริงของภาพขนาดใดขนาดหนึ่ง ใน Responses API ยังต้องคิดค่าโทเคนของโมเดลหลักเพิ่มเติม ตรวจการใช้งานและราคาปัจจุบันก่อนประมาณงบ [1]

สำหรับการสอน แนะนำให้กำหนดโจทย์เดียว ใช้ n=1 และเริ่มทดลองด้วยคุณภาพ low หรือ medium จากนั้นค่อยเพิ่มคุณภาพเมื่อองค์ประกอบผ่านการตรวจแล้ว นี่เป็นแนวทางจัดกิจกรรมที่เสนอในบทความ

#12. เชื่อมต่อกับเว็บแอป

ให้เบราว์เซอร์ส่ง prompt ไปยัง backend จากนั้น backend เรียก OpenAI API ถอดรหัสภาพ เก็บไฟล์ และส่ง URL ของไฟล์ที่แอปจัดเก็บเองกลับให้ผู้ใช้ โดยเก็บ API key ไว้ที่ backend [9]

ข้อเสนอสำหรับแอปที่มีผู้ใช้หลายคน:

• สร้างงานในคิวและส่งหมายเลขงานกลับทันที เพื่อให้หน้าเว็บติดตามสถานะได้
• ตรวจสิทธิ์และจำกัดจำนวนคำขอต่อผู้ใช้ก่อนเรียก API
• เก็บ prompt, model, size, quality และชื่อไฟล์เป็น metadata สำหรับตรวจย้อนหลัง
• กำหนดการเก็บภาพและสิทธิ์ดาวน์โหลดให้สอดคล้องกับงานของระบบ
• ออกแบบการลองใหม่อย่างจำกัด โดยแยกข้อผิดพลาดชั่วคราวออกจาก quota หรือคำขอที่ต้องแก้ไข

รายการนี้เป็นข้อเสนอทางสถาปัตยกรรมของบทความ สามารถปรับตามขนาดระบบและปริมาณผู้ใช้

#13. ปัญหาที่พบบ่อย

สำหรับข้อผิดพลาดชั่วคราวให้ใช้ backoff แบบมีขอบเขต ส่วน quota หรือคำขอที่ต้องแก้ไขไม่ควรถูกส่งซ้ำอย่างต่อเนื่อง อ้างอิง error code และ request ID เมื่อตรวจปัญหา [8]

#14. Workshop สำหรับชั้นเรียน

โจทย์: สร้างภาพหน้าปกบทความและภาพมาสคอตจากแนวคิดเดียวกัน

1. เขียน prompt ที่ระบุหัวข้อ องค์ประกอบ สี และสิ่งที่ต้องไม่มี
2. รันตัวอย่าง Python เพื่อสร้างหน้าปกหนึ่งภาพ
3. ตรวจจำนวนวัตถุ สี พื้นที่หัวข้อ และความคมชัด
4. ใช้ตัวอย่างแก้ภาพเพื่อแยกมาสคอตพื้นหลังโปร่งใส
5. บันทึกชื่อโมเดล prompt พารามิเตอร์ เวลา และต้นทุนที่ตรวจได้จากการใช้งานจริง
6. อภิปรายว่าควรแก้ภาพเดิมหรือสร้างภาพใหม่ เมื่อข้อกำหนดเปลี่ยน

เกณฑ์ประเมินที่เสนอ: ความตรงตามข้อกำหนด 40% ความสมบูรณ์ขององค์ประกอบ 25% คุณภาพภาพและข้อความ 20% และบันทึกการทดลองที่ตรวจสอบได้ 15%

#เอกสารอ้างอิง

ทุกลิงก์ต่อไปนี้เป็นเอกสาร OpenAI ทางการ ตรวจสอบวันที่ 17 ตุลาคม 2026

1. Image generation guide
2. GPT Image 2.5 Flare
3. GPT Image 2.5 Sunburst
4. Create image — Python API reference
5. Image generation tool — Responses API
6. Developer quickstart
7. Create image edit — Python API reference
8. Error codes
9. Production best practices