วิธีใช้งาน OpenAI API

คู่มือนี้จะแนะนำคุณเกี่ยวกับการใช้งาน OpenAI Responses API แบบครบวงจร: เมื่อคุณอ่านจบ คุณจะสามารถส่งคำขอไปยัง POST /v1/responses, อ่านเอาต์พุตที่ซ้อนกันซึ่งส่งกลับมา, เปิดใช้งานเครื่องมือในตัว, รักษาสถานะการสนทนาข้ามการเรียก และยืนยันสัญญาโดยรวมภายใน Apidog Responses API คืออินเทอร์เฟซใหม่ของ OpenAI สำหรับการสร้างเอาต์พุตโมเดล และ คู่มือ Responses อย่างเป็นทางการ อธิบายว่าเหตุใด OpenAI จึงแนะนำให้โปรเจกต์ใหม่ ๆ หันมาใช้ API นี้ หากคุณทดสอบเอนด์พอยต์แบบเก่าอยู่แล้ว คุณสามารถนำการตั้งค่าส่วนใหญ่กลับมาใช้ใหม่ได้ คล้ายกับเวิร์กโฟลว์ใน คู่มือการทดสอบ ChatGPT API ของเรา

ปุ่มดาวน์โหลดแอป

สิ่งที่คุณต้องมีก่อน

ก่อนส่งคำขอ ตรวจสอบให้แน่ใจว่าคุณมีสิ่งต่อไปนี้:

คีย์ OpenAI API ที่สามารถเข้าถึงโมเดลทั่วไปในปัจจุบัน เก็บคีย์ไว้ในตัวแปรสภาพแวดล้อม ไม่ใช่ในคำสั่งหรือไฟล์ที่แชร์
ชื่อโมเดลที่บัญชีของคุณสามารถเรียกใช้ได้ แทนที่จะฮาร์ดโค้ด ควรตรวจสอบรายการโมเดลในแดชบอร์ด OpenAI ของคุณและยืนยันกับเอนด์พอยต์
วิธีการส่งคำขอ HTTP ดิบและตรวจสอบ JSON ที่ส่งกลับมา เทอร์มินัลที่มี curl ใช้ได้สำหรับการเรียกครั้งแรก และ Apidog คือสิ่งที่คุณจะใช้ในการยืนยันและจำลองการตอบกลับในภายหลัง

นอกจากนี้ยังช่วยให้ทราบว่าเอนด์พอยต์ทำอะไรก่อนที่คุณจะเรียกใช้งาน Responses API มีเอนด์พอยต์เดียวคือ POST /v1/responses คุณส่งชื่อโมเดลและ input และคุณจะได้รับวัตถุการตอบกลับที่สามารถมีข้อความธรรมดา การเรียกใช้ฟังก์ชัน และผลลัพธ์ของเครื่องมือที่ OpenAI โฮสต์ เช่น การค้นหาเว็บหรือการค้นหาไฟล์ การเรียกครั้งเดียวสามารถดำเนินการได้หลายขั้นตอน: โมเดลตัดสินใจที่จะค้นหาเว็บ อ่านผลลัพธ์ จากนั้นเขียนคำตอบ และการตอบกลับจะบันทึกทุกขั้นตอนที่ดำเนินการ

มีสองสิ่งที่ทำให้แตกต่างจากเอนด์พอยต์ข้อความธรรมดา ประการแรก สามารถเรียกใช้เครื่องมือในตัวทางฝั่งเซิร์ฟเวอร์ได้ ดังนั้นคุณจึงไม่จำเป็นต้องตั้งค่าการค้นหาหรือแซนด์บ็อกซ์ของคุณเอง ประการที่สอง เป็นแบบ stateful โดยค่าเริ่มต้น การตอบกลับทุกครั้งจะได้รับ id และคุณสามารถส่ง id นั้นไปยังคำขอถัดไปเพื่อให้ OpenAI เก็บประวัติการสนทนาไว้ให้คุณ OpenAI อธิบาย Responses API ว่าเป็นการพัฒนาของ Chat Completions และแนะนำสำหรับโปรเจกต์ใหม่ ๆ โดยรวบรวมบทเรียนจาก Assistants API beta ดังนั้นแทนที่จะมีสามโมเดลความคิด คุณก็มีเพียงหนึ่งเดียว

ทำความเข้าใจว่ามันแตกต่างจาก Chat Completions อย่างไร

หากคุณเคยใช้ POST /v1/chat/completions การเปลี่ยนแปลงส่วนใหญ่จะอยู่ที่รูปร่างและสถานะ Chat Completions ใช้ messages array และส่งกลับ choices คุณจัดการบทสนทนาทั้งหมดด้วยตัวเอง โดยส่งทุกการสนทนาก่อนหน้าซ้ำในการเรียกแต่ละครั้ง เครื่องมือเป็นสิ่งที่คุณต้องนำไปใช้งานเอง

Responses API ใช้ input (สตริงหรือรายการของรายการที่ระบุประเภท) และส่งกลับ output (รายการของรายการที่ระบุประเภท) สามารถจัดเก็บการสนทนาให้คุณและเรียกใช้เครื่องมือที่โฮสต์ได้โดยไม่ต้องมีการตั้งค่าเพิ่มเติม

นี่คือการเปรียบเทียบเชิงปฏิบัติ:

ด้าน	Chat Completions	Responses API
เอนด์พอยต์	`POST /v1/chat/completions`	`POST /v1/responses`
เนื้อหาคำขอ	อาร์เรย์ `messages`	`input` (สตริงหรือรายการ) + `instructions`
รูปแบบเอาต์พุต	`choices[].message`	รายการ `output` ของรายการที่ระบุประเภท
สถานะการสนทนา	คุณต้องส่งประวัติทั้งหมดซ้ำ	`store` + `previous_response_id`
เครื่องมือในตัว	คุณต้องสร้างเอง	`web_search`, `file_search`, `code_interpreter` และอื่นๆ
สถานะ	รองรับ ไม่มีประกาศการเลิกใช้งาน	แนะนำสำหรับโปรเจกต์ใหม่

Chat Completions จะไม่หายไป OpenAI กล่าวว่าจะยังคงรองรับ และคุณสามารถโยกย้ายเวิร์กโฟลว์ผู้ใช้ทีละหนึ่งขั้นตอนแทนที่จะเขียนใหม่ทั้งหมดในครั้งเดียว Assistants API กำลังจะถูกเลิกใช้งาน: OpenAI ได้เลิกใช้งานไปเมื่อวันที่ 26 สิงหาคม 2025 โดยมีกำหนดเลิกใช้ในวันที่ 26 สิงหาคม 2026 ดังนั้นงาน Agent ใหม่ควรเริ่มต้นบน Responses

ทำการเรียกครั้งแรกของคุณ

นี่คือการเรียกขั้นต่ำ เปลี่ยนชื่อโมเดลเป็นสิ่งที่บัญชีของคุณเข้าถึงได้ และเก็บคีย์ของคุณไว้นอกคำสั่ง

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": "Write one sentence describing what an API mock server does.",
    "instructions": "You are a concise technical writer. No marketing language.",
    "store": true
  }'

คุณส่งสามสิ่งที่สำคัญที่นี่: model, input (พรอมต์ของคุณ), และ instructions (การชี้นำระดับระบบ) การตั้งค่า store เป็น true จะบอกให้ OpenAI บันทึกการตอบกลับเพื่อให้คุณสามารถสนทนาต่อได้ในภายหลัง

อ่านการตอบกลับ

การตอบกลับที่ตัดทอนแล้วจะมีลักษณะดังนี้:

{
  "id": "resp_abc123",
  "object": "response",
  "status": "completed",
  "model": "gpt-5.5",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "A mock server returns predefined API responses so clients can be developed and tested before the real backend exists."
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 28,
    "output_tokens": 24,
    "total_tokens": 52
  }
}

โปรดสังเกตโครงสร้าง เพราะเป็นส่วนที่ทำให้ผู้คนสับสน ข้อความที่คุณต้องการอยู่ใน output[0].content[0].text ไม่ใช่ในฟิลด์ระดับบนสุด SDK อย่างเป็นทางการจะเพิ่มตัวช่วย output_text ที่รวมรายการข้อความทั้งหมดเข้าเป็นสตริงเดียว แต่คุณสมบัตินั้นเป็นตัวช่วยของ SDK ไม่ใช่ส่วนหนึ่งของ JSON HTTP ดิบ เมื่อคุณเรียกเอนด์พอยต์โดยตรง คุณจะอ่านพาธที่ซ้อนกัน id ระดับบนสุดคือสิ่งที่คุณจะนำไปใช้ซ้ำสำหรับสถานะ และ usage.total_tokens จะบอกคุณถึงค่าใช้จ่ายของการเรียกนั้น

เพิ่มเครื่องมือในตัว

คุณสมบัติเด่นคือ OpenAI จะเรียกใช้เครื่องมือบางอย่างให้คุณ คุณระบุไว้ในอาร์เรย์ tools และโมเดลจะตัดสินใจว่าจะเรียกใช้เมื่อใด ประเภทในตัวที่ได้รับการยืนยัน ได้แก่:

web_search สำหรับการค้นหาอินเทอร์เน็ตแบบเรียลไทม์พร้อมการอ้างอิง (web_search_preview แบบเก่ายังคงใช้ได้สำหรับการรวมระบบแบบเดิม แต่ไม่มีการควบคุมใหม่)
file_search สำหรับการเรียกข้อมูลจากไฟล์ที่คุณอัปโหลด
code_interpreter สำหรับการรันและวิเคราะห์โค้ดในแซนด์บ็อกซ์
computer_use สำหรับการขับเคลื่อนอินเทอร์เฟซคอมพิวเตอร์
image_generation สำหรับการสร้างภาพในบรรทัด

การเปิดใช้งานทำได้โดยการเพิ่มเล็กน้อยในส่วนเนื้อหา:

{
  "model": "gpt-5.5",
  "input": "What changed in the latest OpenAPI release? Cite sources.",
  "tools": [{ "type": "web_search" }]
}

เมื่อโมเดลใช้เครื่องมือ อาร์เรย์ output จะมีรายการที่บันทึกขั้นตอน เช่น รายการ web_search_call พร้อมกับ message สุดท้าย ซึ่งมีประโยชน์ในภายหลัง: คุณสามารถตรวจสอบว่าเครื่องมือถูกเรียกใช้จริง ไม่ใช่แค่มีข้อความส่งกลับมา

สนทนาต่อในการเรียกข้ามครั้ง

สถานะทำงานผ่านพารามิเตอร์สองตัว store เป็นจริงโดยค่าเริ่มต้น ซึ่งหมายความว่า OpenAI จะบันทึกวัตถุการตอบกลับ (เก็บไว้ 30 วันโดยค่าเริ่มต้น) และส่งคืน id ส่ง id นั้นเป็น previous_response_id ในการเรียกครั้งถัดไปของคุณ และโมเดลจะสนทนาต่อโดยที่คุณไม่ต้องส่งบทสนทนาซ้ำ:

{
  "model": "gpt-5.5",
  "input": "Now rewrite that for a non-technical audience.",
  "previous_response_id": "resp_abc123"
}

หากคุณต้องการรักษาสถานะแบบไร้สถานะ หรือคุณมีข้อกำหนดการไม่เก็บข้อมูล ให้ตั้งค่า store เป็น false และจัดการบริบทด้วยตัวเอง สำหรับการสนทนาด้วยเสียงและเสียงที่มีความหน่วงต่ำแบบเรียลไทม์ OpenAI ใช้พื้นผิวที่แตกต่างกัน คู่มือ GPT realtime API ของเรา ครอบคลุมกรณีนั้น และหากคุณกำลังจัดการเอเจนต์หลายขั้นตอนนอกเหนือจากนี้ รูปแบบจะสอดคล้องกับ OpenAI Agents SDK

วิธีทดสอบใน Apidog

Apidog เป็นแพลตฟอร์มสำหรับการทดสอบ ออกแบบ และจำลอง API ไม่ใช่ OpenAI SDK หรือไลบรารีโค้ด ดังนั้นคุณจะไม่เขียน Python กับมัน สิ่งที่คุณทำแทนคือ: สร้างคำขอ HTTP ดิบไปยัง /v1/responses ส่งมัน และเขียนการยืนยันบน JSON ที่ส่งกลับมา นั่นคือการตรวจสอบสัญญาที่ช่วยจับการรวมระบบที่เสียก่อนที่ผู้ใช้ของคุณจะพบ

นี่คือการตั้งค่าทีละขั้นตอน

เก็บคีย์ไว้ในตัวแปรสภาพแวดล้อม

ใน Apidog สร้างสภาพแวดล้อม (เช่น "OpenAI Prod") และเพิ่มตัวแปรเช่น OPENAI_API_KEY เก็บค่าไว้ในสภาพแวดล้อม ไม่ใช่ในคำขอ เพื่อให้ความลับไม่ถูกบันทึกลงในคอลเลกชันที่แชร์ จากนั้นสร้างคำขอ POST ใหม่ไปยัง https://api.openai.com/v1/responses และเพิ่มส่วนหัว Authorization: Bearer {{OPENAI_API_KEY}} Apidog จะแทนที่ตัวแปรเมื่อถึงเวลาส่ง

ตั้งค่าเนื้อหาเป็น JSON และวางคำขอจากก่อนหน้านี้ กดส่ง คุณจะเห็นวัตถุการตอบกลับทั้งหมดที่จัดรูปแบบแล้ว พร้อมอาร์เรย์ output ที่ซ้อนกัน

ยืนยันฟิลด์การตอบกลับ

การตอบกลับ 200 ที่ประสบความสำเร็จไม่ใช่หลักฐานว่าการตอบกลับมีรูปร่างตามที่แอปของคุณคาดหวัง เพิ่มการยืนยันเพื่อให้การถดถอยล้มเหลวอย่างชัดเจน การตรวจสอบที่เป็นประโยชน์ต่อการตอบกลับ /v1/responses:

status เท่ากับ completed
output[0].content[0].text มีอยู่และไม่ว่างเปล่า
usage.total_tokens มากกว่า 0
เมื่อคุณส่ง tools รายการใน output มี type เท่ากับ web_search_call

เครื่องมือสร้างการยืนยันแบบภาพของ Apidog ช่วยให้คุณกำหนดเป้าหมายพาธ JSON เหล่านั้นได้โดยไม่ต้องเขียนสคริปต์ทดสอบ และ เทมเพลตกรณีทดสอบ API ของเราแสดงวิธีการจัดโครงสร้างการตรวจสอบเหล่านี้ บันทึกคำขอลงในคอลเลกชัน และมันจะกลายเป็นการทดสอบที่ทำซ้ำได้ที่คุณสามารถเรียกใช้ใน CI

จำลองการตอบกลับสำหรับการพัฒนาแบบออฟไลน์

การเรียก OpenAI มีค่าใช้จ่ายและต้องการการเข้าถึงเครือข่าย ซึ่งไม่สะดวกเมื่อคุณกำลังสร้าง UI ที่ใช้การตอบกลับหรือรันการทดสอบในไปป์ไลน์ที่ไม่ควรเรียกใช้ API แบบชำระเงิน คุณสมบัติจำลองของ Apidog แก้ปัญหานี้ได้ บันทึกเพย์โหลด /v1/responses ที่เป็นตัวแทนเป็น mock ชี้แอปของคุณไปยัง URL mock ของ Apidog และส่วนหน้าของคุณจะได้รับรูปแบบ JSON ที่ถูกต้องโดยไม่มีการใช้โทเค็น เมื่อเอนด์พอยต์จริงเปลี่ยนไป คุณอัปเดต mock เพียงตัวเดียวแทนที่จะไล่ตามความล้มเหลวในการทดสอบทุกครั้ง คำอธิบาย API จำลอง ของเราจะอธิบายแนวทางทั่วไป

การแยกนี้สำคัญ คุณทดสอบกับเอนด์พอยต์จริงเพื่อตรวจสอบสัญญาของ OpenAI และคุณจำลองมันสำหรับการพัฒนาที่รวดเร็ว ออฟไลน์ และกำหนดได้ ทั้งสองอย่างทำงานจากโปรเจกต์ Apidog เดียวกัน

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

Responses API จะมาแทนที่ Chat Completions หรือไม่?

ไม่ได้บังคับ OpenAI เรียก Responses ว่าเป็นการพัฒนาของ Chat Completions และแนะนำสำหรับโปรเจกต์ใหม่ แต่ Chat Completions ยังคงรองรับโดยไม่มีการประกาศวันเลิกใช้งาน คุณสามารถโยกย้ายเวิร์กโฟลว์ทีละหนึ่งขั้นตอน Assistants API เป็นตัวที่กำลังจะเลิกใช้งาน โดยมีวันสิ้นสุดในปี 2026

ความแตกต่างระหว่าง `store` และ `previous_response_id` คืออะไร?

store ควบคุมว่า OpenAI จะบันทึกวัตถุการตอบกลับทั้งหมดหรือไม่ (ค่าเริ่มต้นคือจริงและเก็บไว้ 30 วัน) previous_response_id คือวิธีที่คุณเชื่อมโยงคำขอใหม่กับคำขอที่เก็บไว้เพื่อให้โมเดลสนทนาต่อทางฝั่งเซิร์ฟเวอร์ คุณใช้มันร่วมกันสำหรับเธรดที่มีสถานะ และปิด store เมื่อคุณต้องการพฤติกรรมแบบไร้สถานะ

โมเดลใดบ้างที่รองรับ Responses API?

โมเดลทั่วไปในปัจจุบันของ OpenAI ได้รับการออกแบบมาเพื่อทำงานร่วมกับ Responses API แต่ความพร้อมใช้งานขึ้นอยู่กับบัญชีของคุณและโมเดลที่คุณเลือก แทนที่จะฮาร์ดโค้ดชื่อโมเดล ควรตรวจสอบรายการโมเดลในแดชบอร์ด OpenAI ของคุณ แล้วยืนยันกับเอนด์พอยต์ การส่งคำขออย่างรวดเร็วผ่าน Apidog และการอ่านฟิลด์ model ในการตอบกลับเป็นวิธีที่รวดเร็วในการตรวจสอบว่าคีย์ของคุณสามารถเรียกอะไรได้บ้าง

ฉันสามารถทดสอบเครื่องมือในตัวโดยไม่ต้องเขียนโค้ดได้หรือไม่?

ใช่ เพิ่มอาร์เรย์ tools ในเนื้อหา JSON ใน Apidog ส่งคำขอ และยืนยันว่ารายการการเรียกใช้เครื่องมือที่ตรงกัน (เช่น web_search_call) ปรากฏในอาร์เรย์ output คุณกำลังตรวจสอบพฤติกรรมของ OpenAI ผ่าน HTTP ดังนั้นจึงไม่จำเป็นต้องมี SDK สำหรับการทดสอบการเรียกใช้เครื่องมือ agent ในวงกว้างขึ้น โปรดดู วิธีสร้างชุดการทดสอบ API จาก OpenAPI specs

สรุป

ตอนนี้คุณมีวงจรที่สมบูรณ์แล้ว: เอนด์พอยต์เดียวคือ POST /v1/responses ซึ่งจัดการข้อความ เครื่องมือที่โฮสต์ และสถานะการสนทนาทางฝั่งเซิร์ฟเวอร์ ส่งคำขอ อ่าน output ที่ซ้อนกัน เพิ่มอาร์เรย์ tools เมื่อคุณต้องการการค้นหาหรือการดำเนินการโค้ด และเชื่อมโยง previous_response_id เพื่อรักษาสถานะการสนทนา เนื่องจากรูปร่างแตกต่างจาก Chat Completions การดำเนินการที่ปลอดภัยที่สุดคือการยืนยันสัญญาด้วยตัวคุณเอง แทนที่จะเชื่อความจำของคุณเกี่ยวกับ API แบบเก่า

นั่นคือที่ที่ Apidog เข้ามามีบทบาท สร้างคำขอ เก็บกุญแจของคุณเป็นตัวแปรสภาพแวดล้อม ยืนยันฟิลด์ output ที่ซ้อนกัน และจำลองการตอบกลับสำหรับการทำงานแบบออฟไลน์ ทั้งหมดในโปรเจกต์เดียว ดาวน์โหลด Apidog และชี้การทดสอบไปที่ /v1/responses เพื่อดูว่าการรวมระบบของคุณได้รับอะไรบ้าง คุณสามารถตั้งค่าทั้งหมดใน Apidog ได้โดยไม่ต้องเขียนโค้ดทดสอบแม้แต่บรรทัดเดียว