Sora 2 Pro แตกต่างจาก Sora 2 มาตรฐานอย่างไร?

Sora 2 Pro ได้รับการปรับจูนเพื่อความเที่ยงตรงของภาพที่สูงขึ้น รับมือช็อตที่ยากขึ้น (การเคลื่อนไหวที่ซับซ้อน การบดบัง ปฏิสัมพันธ์ทางกายภาพ) และรักษาความคงเส้นคงวาต่อฉากได้นานขึ้น—แลกกับเวลาการเรนเดอร์ที่นานขึ้น.

Sora 2 Pro ใช้เวลาเรนเดอร์วิดีโอนานเท่าไร?

การทดสอบ Benchmark แสดงว่า Sora 2 Pro ใช้เวลาเฉลี่ยประมาณ 2.1 นาทีสำหรับคลิป 1080p ความยาว 20 วินาที รุ่น Pro ให้ความสำคัญกับคุณภาพมากกว่าความเร็ว ดังนั้นคาดว่าเวลาการเรนเดอร์จะนานกว่า Sora 2 มาตรฐาน.

Sora 2 Pro มีการปรับปรุงด้านฟิสิกส์อย่างไรบ้าง?

Sora 2 Pro ปรับปรุงความคงอยู่ของวัตถุและความเที่ยงตรงของการเคลื่อนไหว—โมเมนตัม แรงลอยตัว และปฏิสัมพันธ์ทางกายภาพดูสมจริงยิ่งขึ้น พร้อมลดอาร์ติแฟกต์แบบ 'teleporting' ที่พบได้บ่อยในโมเดลวิดีโอรุ่นก่อน.

ควรเลือก Sora 2 Pro แทน Google Veo 3 เมื่อใด?

เลือก Sora 2 Pro สำหรับการผสานรวมกับระบบนิเวศของ OpenAI, likeness injection, และฉากทางกายภาพที่ซับซ้อน Veo 3 อาจให้การสร้างที่เร็วกว่าและมีการตั้งราคาที่แตกต่าง—ประเมินตามความต้องการด้านความหน่วงและงบประมาณของคุณ.

Sora 2 Pro รองรับ likeness injection (cameos) หรือไม่?

ใช่, Sora 2 Pro สามารถแทรกภาพเหมือนของผู้ใช้ที่บันทึกไว้เข้าไปในฉากที่สร้างขึ้นได้ OpenAI มีเวิร์กโฟลว์การให้ความยินยอมและกลไกการเพิกถอนในตัวเพื่อจัดการความเสี่ยงด้านความเป็นส่วนตัวและการใช้ในทางที่ผิด.

Sora 2 Pro รองรับความละเอียดและระยะเวลาแบบใด?

Sora 2 Pro รองรับความละเอียดได้สูงสุด 1080p ได้รับการปรับให้เหมาะสำหรับคลิปสั้นคุณภาพสูง โดยทั่วไปอยู่ในช่วงหลักหน่วยวินาทีไปจนถึงสิบวินาทีต้นๆ เพื่อให้ได้ความเที่ยงตรงสูงสุด.

Sora 2 Pro สร้างเสียงที่ซิงโครไนซ์กับวิดีโอหรือไม่?

ใช่, Sora 2 Pro สร้างเฟรมวิดีโอพร้อมเสียงที่ซิงโครไนซ์ รวมถึงบทสนทนา เสียงบรรยากาศ และเอฟเฟ็กต์เสียง—ไม่ได้ผลิตแยกกัน แต่เป็นผลลัพธ์แบบรวมเดียว.

Sora 2 Pro สามารถใช้ภาพอ้างอิงเพื่อกำกับการสร้างวิดีโอได้หรือไม่?

ใช่, Sora 2 Pro รองรับเวิร์กโฟลว์ input_reference ที่รูปภาพ JPEG/PNG/WEBP ทำหน้าที่เป็นจุดยึดองค์ประกอบ เพื่อกำกับเฟรมเริ่มต้นหรือสไตล์ของวิดีโอที่สร้างขึ้น.

OpenAI

พร้อมใช้งาน

sora-2-pro

Sora 2 Pro API

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

ราคาเริ่มต้น

$0.24 / วินาที

คิดค่าบริการตามการใช้งาน

สถานะ API

พร้อมใช้งาน

เอนด์พอยต์สำหรับโปรดักชัน

เวลาตอบสนอง

รองรับการทำงานแบบ async

เวลาตอบสนอง API ที่วัดได้จริง

วันที่เผยแพร่

May 31, 2026

OpenAI

Playground

ลองใช้ Sora 2 Pro ด้วยคำขอจริง ตรวจสอบพารามิเตอร์ และตรวจสอบผลลัพธ์ก่อนเชื่อมต่อ API

ภาพรวม

ภาพรวมการใช้งานจริงของ Sora 2 Pro รวมถึงพฤติกรรมสำคัญและข้อควรพิจารณาในการเชื่อมต่อ

คุณสมบัติสำคัญ

การสร้างแบบหลายโมดัล (วิดีโอ + เสียง) — Sora-2-Pro สร้างเฟรมวิดีโอพร้อมเสียงที่ซิงโครไนซ์ (บทสนทนา เสียงบรรยากาศ SFX) แทนการผลิตวิดีโอและเสียงแยกกัน
ความเที่ยงตรงสูง / ระดับ “Pro” — ปรับจูนเพื่อให้ได้ ความเที่ยงตรงด้านภาพที่สูงกว่า รับมือช็อตที่ยาก (การเคลื่อนไหวซับซ้อน การบังกัน และปฏิสัมพันธ์ทางกายภาพ) และคงความสม่ำเสมอต่อฉากได้นานกว่า Sora-2 (non-Pro) อาจใช้เวลาสร้างผลลัพธ์นานกว่ารุ่นมาตรฐาน Sora-2
ความยืดหยุ่นของอินพุต — รองรับพรอมต์แบบข้อความล้วน และรับเฟรมภาพอินพุตหรือภาพอ้างอิงเพื่อกำหนดองค์ประกอบ (เวิร์กโฟลว์ input_reference)
Cameos / likeness injection — สามารถแทรกภาพเหมือนของผู้ใช้ที่บันทึกไว้ลงในฉากที่สร้างขึ้น โดยใช้เวิร์กโฟลว์การให้ความยินยอมในแอป
ความสมจริงทางกายภาพ: ปรับปรุงการคงอยู่ของวัตถุและความเที่ยงตรงของการเคลื่อนไหว (เช่น โมเมนตัม แรงลอยตัว) ลดอาร์ติแฟกต์แบบ “teleporting” ที่ไม่สมจริงซึ่งพบได้บ่อยในระบบรุ่นก่อน
การควบคุมได้: รองรับพรอมต์แบบมีโครงสร้างและคำสั่งระดับช็อต เพื่อให้ผู้สร้างระบุการตั้งค่ากล้อง แสง และลำดับหลายช็อตได้

รายละเอียดเชิงเทคนิคและพื้นที่การผสานรวม

ตระกูลโมเดล: Sora 2 (ฐาน) และ Sora 2 Pro (รุ่นคุณภาพสูง)
รูปแบบอินพุต: พรอมต์ข้อความ ภาพอ้างอิง และวิดีโอ/เสียง cameo แบบสั้นที่บันทึกไว้สำหรับภาพเหมือน
รูปแบบเอาต์พุต: วิดีโอที่เข้ารหัส (พร้อมเสียง) — พารามิเตอร์ถูกเปิดเผยผ่านปลายทาง /v1/videos (เลือกโมเดลผ่าน model: "sora-2-pro") API surface สอดคล้องกับตระกูลปลายทางวิดีโอของ OpenAI สำหรับการสร้าง/ดึง/แสดงรายการ/ลบ

การฝึกและสถาปัตยกรรม (สรุสาธารณะ): OpenAI อธิบายว่า Sora 2 ผ่านการฝึกบนข้อมูลวิดีโอขนาดใหญ่ พร้อมการปรับแต่งหลังการฝึกเพื่อพัฒนาความสามารถด้านการจำลองโลก; รายละเอียดเฉพาะ (ขนาดโมเดล ชุดข้อมูลที่แน่ชัด และการโทเคไนซ์) ไม่ได้เปิดเผยแบบระบุทีละรายการ คาดว่ามีการใช้คอมพิวต์ขนาดใหญ่ ตัวแยกโทเค็น/สถาปัตยกรรมวิดีโอเฉพาะทาง และองค์ประกอบการจัดแนวแบบมัลติโหมด

API endpoints & เวิร์กโฟลว์: ใช้เวิร์กโฟลว์แบบงาน (job): ส่งคำขอสร้างแบบ POST (model="sora-2-pro"), รับรหัสงานหรือที่ตั้ง จากนั้นโพลหรือรอให้เสร็จสิ้นแล้วดาวน์โหลดไฟล์ผลลัพธ์ พารามิเตอร์ที่พบบ่อยในตัวอย่างที่เผยแพร่ ได้แก่ prompt, seconds/duration, size/resolution และ input_reference สำหรับการเริ่มต้นแบบมีภาพกำกับ

พารามิเตอร์ทั่วไป:

model: "sora-2-pro"
prompt: คำอธิบายฉากแบบภาษาธรรมชาติ อาจใส่บทสนทนาด้วยก็ได้
seconds / duration: ความยาวคลิปเป้าหมาย (Pro รองรับคุณภาพสูงสุดภายในช่วงความยาวที่มีให้)
size / resolution: รายงานจากชุมชนระบุว่า Pro รองรับได้สูงสุดถึง 1080p ในหลายกรณีการใช้งาน

อินพุตเนื้อหา: สามารถส่งไฟล์รูปภาพ (JPEG/PNG/WEBP) เป็นเฟรมหรือภาพอ้างอิง; เมื่อใช้งาน ควรให้ภาพตรงกับความละเอียดเป้าหมายและทำหน้าที่เป็นจุดยึดองค์ประกอบ

พฤติกรรมการเรนเดอร์: รุ่น Pro ปรับจูนให้ให้ความสำคัญกับความสอดคล้องระหว่างเฟรมและความสมจริงทางฟิสิกส์; โดยทั่วไปหมายถึงใช้เวลาคำนวณนานขึ้นและมีค่าใช้จ่ายต่อคลิปสูงกว่ารุ่น non-Pro

ประสิทธิภาพตามเกณฑ์

จุดแข็งเชิงคุณภาพ: OpenAI ปรับปรุงความสมจริง ความสอดคล้องทางฟิสิกส์ และการซิงโครไนซ์เสียง เทียบกับรุ่นสร้างวิดีโอก่อนหน้า ผลลัพธ์ VBench อื่นๆ ชี้ว่า Sora-2 และรุ่นย่อยอยู่ในระดับแนวหน้าของระบบปิดและความสอดคล้องตามเวลา

เวลา/ทรูกำลัง (ตัวอย่างเปรียบเทียบ): Sora-2-Pro ใช้เวลาเฉลี่ยประมาณ ~2.1 นาที สำหรับคลิป 20 วินาทีที่ 1080p ในหนึ่งการเปรียบเทียบ ขณะที่คู่แข่ง (Runway Gen-3 Alpha Turbo) เร็วกว่า (~1.7 นาที) ในงานเดียวกัน — เป็นการแลกเปลี่ยนระหว่างคุณภาพกับเวลาเรนเดอร์และการปรับแต่งแพลตฟอร์ม

ข้อจำกัด (เชิงปฏิบัติ & ความปลอดภัย)

ฟิสิกส์/ความสม่ำเสมอไม่สมบูรณ์แบบ — แม้ดีขึ้นแต่ยังอาจมีอาร์ติแฟกต์ การเคลื่อนไหวไม่เป็นธรรมชาติ หรือความคลาดเคลื่อนการซิงค์เสียง
ข้อจำกัดด้านความยาวและคอมพิวต์ — คลิปยาวต้องใช้ทรัพยากรมาก; เวิร์กโฟลว์จำนวนมากจึงจำกัดความยาวคลิปให้สั้น (เช่น หลักไม่กี่วินาทีถึงหลักสิบวินาที สำหรับคุณภาพสูง)
ความเป็นส่วนตัว/ความยินยอม — likeness injection (“cameos”) มีความเสี่ยงด้านความยินยอมและข้อมูลเท็จ; OpenAI มีการควบคุมด้านความปลอดภัยและกลไกเพิกถอนในแอป แต่ต้องผสานอย่างมีความรับผิดชอบ
ต้นทุน & ระยะหน่วง — การเรนเดอร์คุณภาพ Pro มีค่าใช้จ่ายและช้ากว่าโมเดลที่เบากว่า/คู่แข่ง; ควรคำนึงถึงการคิดค่าบริการต่อวินาที/ต่อการเรนเดอร์และการเข้าคิว
การกรองด้านความปลอดภัยของเนื้อหา — จำกัดการสร้างเนื้อหาที่เป็นอันตรายหรือมีลิขสิทธิ์; โมเดลและแพลตฟอร์มมีเลเยอร์ความปลอดภัยและการกลั่นกรอง

กรณีใช้งานทั่วไปและที่แนะนำ

กรณีใช้งาน:

การตลาด & ต้นแบบโฆษณา — สร้างงานต้นแบบเชิงภาพยนตร์อย่างรวดเร็ว
พรีวิชวลไลเซชัน — สตอรีบอร์ด การวางกล้อง การดูภาพช็อต
คอนเทนต์สั้นสำหรับโซเชียล — คลิปสไตล์ต่างๆ พร้อมบทสนทนาและเอฟเฟกต์เสียงที่ซิงค์กัน
วิธีเข้าถึง Sora 2 Pro API

ขั้นตอนที่ 1: ลงทะเบียนเพื่อรับ API Key

ล็อกอินที่ cometapi.com หากคุณยังไม่เป็นผู้ใช้ของเรา โปรดสมัครสมาชิกก่อน ลงชื่อเข้าใช้ คอนโซล CometAPI รับ API key สิทธิ์การเข้าถึงของอินเทอร์เฟซ คลิก “Add Token” ที่ API token ในศูนย์ส่วนบุคคล รับโทเค็นคีย์: sk-xxxxx และส่ง

cometapi-key

ขั้นตอนที่ 2: ส่งคำขอไปยัง Sora 2 Pro API

เลือกปลายทาง “sora-2-pro” เพื่อส่งคำขอ API และกำหนด request body วิธีการและ request body สามารถดูได้จากเอกสาร API บนเว็บไซต์ของเรา เว็บไซต์ของเรายังมีการทดสอบผ่าน Apifox เพื่อความสะดวก โปรดแทนที่ <YOUR_API_KEY> ด้วย CometAPI key จริงจากบัญชีของคุณ base url is office Create video

ใส่คำถามหรือคำขอของคุณลงในฟิลด์ content — นี่คือส่วนที่โมเดลจะตอบสนอง ประมวลผลการตอบกลับของ API เพื่อรับคำตอบที่สร้างขึ้น

ขั้นตอนที่ 3: ดึงและยืนยันผลลัพธ์

ประมวลผลการตอบกลับของ API เพื่อรับคำตอบที่สร้างขึ้น หลังการประมวลผล API จะตอบกลับด้วยสถานะงานและข้อมูลผลลัพธ์

การฝึกภายใน/การจำลอง — สร้างภาพสถานการณ์สำหรับงานวิจัย RL หรือโรบอติกส์ (ด้วยความระมัดระวัง)
งานโปรดักชันเชิงสร้างสรรค์ — เมื่อนำไปต่อยอดด้วยการตัดต่อของมนุษย์ (ต่อคลิปสั้นๆ เกรดดิ้ง แทนที่เสียง)

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

ราคา

ใช้การประเมินค่าใช้จ่ายอย่างรวดเร็วด้านบนสำหรับการรันครั้งเดียว จากนั้นดูการเปรียบเทียบราคาฉบับเต็มระหว่าง CometAPI และราคาทางการ

ทดสอบ 5 วินาที

$1.20

ค่าใช้จ่ายโดยประมาณของ CometAPI

ทดสอบ 10 วินาที

$2.40

ค่าใช้จ่ายโดยประมาณของ CometAPI

ทดสอบ 15 วินาที

$3.60

ค่าใช้จ่ายโดยประมาณของ CometAPI

ราคาสำหรับ Sora 2 Pro

สำรวจราคาที่แข่งขันได้สำหรับ Sora 2 Pro ที่ออกแบบมาให้เหมาะสมกับงบประมาณและความต้องการการใช้งานที่หลากหลาย แผนการบริการที่ยืดหยุ่นของเรารับประกันว่าคุณจะจ่ายเฉพาะสิ่งที่คุณใช้เท่านั้น ทำให้สามารถขยายขนาดได้ง่ายเมื่อความต้องการของคุณเพิ่มขึ้น ค้นพบว่า Sora 2 Pro สามารถยกระดับโปรเจกต์ของคุณได้อย่างไรในขณะที่ควบคุมต้นทุนให้อยู่ในระดับที่จัดการได้

Model Name	Tags	Orientation	Resolution	Price
sora-2-pro	videos	Portrait	720x1280	$0.24 / sec
sora-2-pro	videos	Landscape	1280x720	$0.24 / sec
sora-2-pro	videos	Portrait (High Res)	1024x1792	$0.40 / sec
sora-2-pro	videos	Landscape (High Res)	1792x1024	$0.40 / sec
sora-2-pro-all	-	Universal / All	-	$0.80000

API

คัดลอกเอนด์พอยต์และตัวอย่างโค้ดที่ใช้งานได้จริง จากนั้นเปิดเอกสารอ้างอิง API ฉบับเต็มเมื่อต้องการพารามิเตอร์ทั้งหมด

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

ยืนยันตัวตนเพียงครั้งเดียว เรียกใช้เอนด์พอยต์ของโมเดล และคงเวิร์กโฟลว์การเรียกเก็บเงินและการตรวจสอบแบบเดียวกันในทุกผู้ให้บริการ

POST/v1/videos

โค้ดตัวอย่างและ API สำหรับ Sora 2 Pro

Sora-2-pro เป็นโมเดลการสร้างวิดีโอและเสียงระดับเรือธงของ OpenAI ออกแบบมาเพื่อสร้างคลิปวิดีโอสั้นที่สมจริงสูง พร้อมบทสนทนาและเอฟเฟกต์เสียงที่ซิงโครไนซ์กัน และมีความสามารถในการจำลองฟิสิกส์/โลกที่แข็งแกร่งกว่าบรรดาโมเดลวิดีโอก่อนหน้า โดยถูกวางตำแหน่งให้เป็นเวอร์ชัน “Pro” คุณภาพสูงสำหรับผู้ใช้แบบชำระเงิน และสามารถเข้าถึงได้ผ่าน API เพื่อการสร้างเชิงโปรแกรม โมเดลนี้ให้ความสำคัญกับความสามารถในการควบคุม ความสอดคล้องเชิงเวลา และการซิงโครไนซ์เสียง สำหรับกรณีใช้งานเชิงภาพยนตร์และสื่อสังคมออนไลน์

POST

/v1/videos

# Create a video with sora-2-pro
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=sora-2-pro" \
  -F "prompt=A calico cat playing a piano on stage")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '
' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")

  # Parse progress from "progress": "0%" format
  progress=$(echo "$status_response" | grep -o '"progress":"[^"]*"' | head -1 | sed 's/"progress":"//;s/"$//')
  # Parse status from the outer level
  status=$(echo "$status_response" | grep -o '"status":"[^"]*"' | head -1 | sed 's/"status":"//;s/"$//')

  echo "Progress: $progress, Status: $status"

  if [ "$progress" = "100%" ]; then
    echo "Video generation completed!"
    break
  fi

  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ]; then
    echo "Video generation failed!"
    echo "$status_response"
    exit 1
  fi

  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

cURL Code Example

# Create a video with sora-2-pro
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=sora-2-pro" \
  -F "prompt=A calico cat playing a piano on stage")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '\n' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")
  
  # Parse progress from "progress": "0%" format
  progress=$(echo "$status_response" | grep -o '"progress":"[^"]*"' | head -1 | sed 's/"progress":"//;s/"$//')
  # Parse status from the outer level
  status=$(echo "$status_response" | grep -o '"status":"[^"]*"' | head -1 | sed 's/"status":"//;s/"$//')
  
  echo "Progress: $progress, Status: $status"
  
  if [ "$progress" = "100%" ]; then
    echo "Video generation completed!"
    break
  fi
  
  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ]; then
    echo "Video generation failed!"
    echo "$status_response"
    exit 1
  fi
  
  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

Python Code Example

# Create a video with sora-2-pro using raw HTTP requests
import os
import time
import requests

api_key = os.environ.get("COMETAPI_KEY")
base_url = "https://api.cometapi.com/v1"

headers = {"Authorization": f"Bearer {api_key}"}

# Step 1: Submit the video generation request
print("Submitting video generation request...")
response = requests.post(
    f"{base_url}/videos",
    headers=headers,
    files={
        "model": (None, "sora-2-pro"),
        "prompt": (None, "A calico cat playing a piano on stage"),
    },
)

result = response.json()
print(f"Response: {result}")

video_id = result.get("id")
print(f"Video ID: {video_id}")

# Step 2: Poll for progress until 100%
print("\nChecking video generation progress...")
while True:
    try:
        status_response = requests.get(f"{base_url}/videos/{video_id}", headers=headers)
        status_result = status_response.json()

        # Parse progress and status from response
        data = status_result.get("data", {})
        if data is None:
            data = {}
        progress = data.get("progress", "0%")
        status = data.get("status", "unknown")

        print(f"Progress: {progress}, Status: {status}")

        if status in ["FAILURE", "failed"]:
            print("Video generation failed!")
            print(status_result)
            exit(1)

        if progress == "100%":
            print("Video generation completed!")
            break
    except Exception as e:
        print(f"Temporary error: {e}, retrying...")

    time.sleep(10)

# Step 3: Download the video to output directory
print(f"\nDownloading video to ./output/{video_id}.mp4...")
os.makedirs("./output", exist_ok=True)

video_response = requests.get(f"{base_url}/videos/{video_id}/content", headers=headers)

output_path = f"./output/{video_id}.mp4"
with open(output_path, "wb") as f:
    f.write(video_response.content)

if os.path.exists(output_path):
    file_size = os.path.getsize(output_path)
    print(f"Video saved to {output_path}")
    print(f"File size: {file_size} bytes")
else:
    print("Failed to download video")
    exit(1)

JavaScript Code Example

// Create a video with sora-2-pro using raw HTTP requests
import fs from "fs";
import path from "path";

const apiKey = process.env.COMETAPI_KEY;
const baseUrl = "https://api.cometapi.com/v1";

async function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function main() {
  // Step 1: Submit the video generation request
  console.log("Submitting video generation request...");

  const formData = new FormData();
  formData.append("model", "sora-2-pro");
  formData.append("prompt", "A calico cat playing a piano on stage");

  const submitResponse = await fetch(`${baseUrl}/videos`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
    body: formData,
  });

  const result = await submitResponse.json();
  console.log("Response:", JSON.stringify(result, null, 2));

  const videoId = result.id;
  console.log("Video ID:", videoId);

  // Step 2: Poll for progress until 100%
  console.log("\nChecking video generation progress...");

  while (true) {
    try {
      const statusResponse = await fetch(`${baseUrl}/videos/${videoId}`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
      });

      const text = await statusResponse.text();
      if (text.startsWith("<")) {
        console.log("Temporary server error, retrying...");
        await sleep(10000);
        continue;
      }

      const statusResult = JSON.parse(text);

      // Parse progress and status from response
      const data = statusResult.data || {};
      const progress = data.progress || "0%";
      const status = data.status || "unknown";

      console.log(`Progress: ${progress}, Status: ${status}`);

      if (status === "FAILURE" || status === "failed") {
        console.log("Video generation failed!");
        console.log(JSON.stringify(statusResult, null, 2));
        process.exit(1);
      }

      if (progress === "100%") {
        console.log("Video generation completed!");
        break;
      }
    } catch (e) {
      console.log(`Temporary error: ${e.message}, retrying...`);
    }

    await sleep(10000);
  }

  // Step 3: Download the video to output directory
  console.log(`\nDownloading video to ./output/${videoId}.mp4...`);

  const outputDir = "./output";
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  const videoResponse = await fetch(`${baseUrl}/videos/${videoId}/content`, {
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
  });

  const outputPath = path.join(outputDir, `${videoId}.mp4`);
  const videoBuffer = Buffer.from(await videoResponse.arrayBuffer());
  fs.writeFileSync(outputPath, videoBuffer);

  if (fs.existsSync(outputPath)) {
    const stats = fs.statSync(outputPath);
    console.log(`Video saved to ${outputPath}`);
    console.log(`File size: ${stats.size} bytes`);
  } else {
    console.log("Failed to download video");
    process.exit(1);
  }
}

main().catch(console.error);

ความสามารถ

ตรวจสอบข้อมูลสำคัญของโมเดลก่อนเลือกสถาปัตยกรรมหรือประเมินภาระงานในโปรดักชัน

ความสามารถที่รองรับ

ฟีเจอร์ที่ส่งกลับโดย API ของโมเดลปัจจุบัน

text-to-video

image-to-video

อินพุตและเอาต์พุต

อินพุต

text

เอาต์พุต

video

โปรไฟล์การใช้งานจริง

ผู้ให้บริการ: OpenAI
บริบท: ขึ้นอยู่กับโมเดล
การใช้งานเชิงพาณิชย์: รองรับ

กรณีการใช้งาน

ใช้ Sora 2 Pro สำหรับเวิร์กโฟลว์ระดับโปรดักชันที่เหมาะกับความสามารถด้าน video จากนั้นเปรียบเทียบทางเลือกอื่นก่อนตัดสินใจเชื่อมต่อระยะยาว

แนวคิดข้อความเป็นวิดีโอและคอนเทนต์โซเชียล

การสาธิตสินค้าและสตอรีบอร์ดสไตล์ภาพยนตร์

การเคลื่อนไหวจากภาพสู่วิดีโอและการทำซ้ำเชิงสร้างสรรค์

โมเดลอื่น ๆ

เปรียบเทียบโมเดลอื่น ๆ ที่มีให้บริการผ่าน CometAPI ในด้านคุณภาพ ความหน่วง ความสามารถ และราคา

เปิดการเปรียบเทียบโมเดล →

Aliyun

Wan3.0

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

ดูโมเดล

MiniMax

MiniMax H3

minimax-h3 เป็นโมเดลการสร้างวิดีโอรุ่นใหม่ที่ออกแบบมาเพื่อการผลิตงานสร้างสรรค์คุณภาพสูง ทั้งยังมอบความเข้าใจพรอมต์ที่ดีขึ้น ความสม่ำเสมอทางภาพที่มากขึ้น การเคลื่อนไหวที่ลื่นไหลยิ่งขึ้น และการควบคุมภาพอ้างอิงที่ยืดหยุ่นมากขึ้น สำหรับเวิร์กโฟลว์การสร้างวิดีโอเชิงภาพยนตร์

ดูโมเดล

Bytedance

Seedance 2.5

seedance-2-5 เป็นโมเดลการสร้างเสียงและวิดีโอแบบร่วมกันเจเนอเรชันถัดไป ที่สร้างมาเพื่อการเล่าเรื่องความยาว 30 วินาที พร้อมการควบคุมจากข้อมูลอ้างอิงอย่างแม่นยำและความสามารถในการตัดต่ออันทรงพลัง

ดูโมเดล

Flux

Flux 3

FLUX 3 - แบบจำลองโลกจริง: มุ่งสู่แบบจำลองโฟลว์แบบหลายโมดาลิตีในฐานะกระดูกสันหลังของปัญญาด้านการมองเห็น.

ดูโมเดล

Bytedance

Seedance 2-0

Seedance 2.0 คือโมเดลพื้นฐานวิดีโอแบบมัลติโมดัลเจเนอเรชันถัดไปของ ByteDance ที่มุ่งเน้นการสร้างวิดีโอเล่าเรื่องแบบหลายช็อตในสไตล์ภาพยนตร์ แตกต่างจากเดโมแปลงข้อความเป็นวิดีโอแบบช็อตเดียว Seedance 2.0 ให้ความสำคัญกับการควบคุมแบบอ้างอิง (ภาพ, คลิปสั้น, เสียง) ความสอดคล้องและความคงเส้นคงวาของตัวละคร/สไตล์ข้ามช็อต และการซิงโครไนซ์เสียง/วิดีโอในตัว — โดยมีเป้าหมายเพื่อทำให้วิดีโอ AI มีประโยชน์ต่อเวิร์กโฟลว์การสร้างสรรค์ระดับมืออาชีพและการพรีวิชวลไลเซชัน

ดูโมเดล

Aliyun

Happy Horse 1.1

HappyHorse 1.1 คือโมเดลสร้างวิดีโอแบบมัลติโหมด ออกแบบมาสำหรับการสร้างคอนเทนต์ระดับมืออาชีพ การโฆษณา หนังสั้น การผลิตสื่อบนโซเชียลมีเดีย และการเล่าเรื่อง ความสามารถของรุ่นนี้ต่อยอดมาจาก HappyHorse 1.0—ซึ่งได้รับความสนใจอย่างมากหลังจากติดอันดับสูงในการประเมินการสร้างวิดีโอโดยอิสระ—ด้วยความสอดคล้องของฉากที่ดีขึ้นและความเที่ยงตรงด้านภาพที่สูงขึ้น.

ดูโมเดล

Uptime

ตรวจสอบข้อมูล heartbeat แบบเรียลไทม์ ความพร้อมใช้งานของเอนด์พอยต์ และเวลาตอบสนองที่วัดได้จริงก่อนใช้งานจริง

สำรวจต่อ

เปรียบเทียบโมเดลและค้นคว้าต่อ

OpenAI

พร้อมใช้งาน

sora-2-pro

Sora 2 Pro API

ราคาเริ่มต้น

$0.24 / วินาที

คิดค่าบริการตามการใช้งาน

สถานะ API

พร้อมใช้งาน

เอนด์พอยต์สำหรับโปรดักชัน

เวลาตอบสนอง

รองรับการทำงานแบบ async

เวลาตอบสนอง API ที่วัดได้จริง

วันที่เผยแพร่

May 31, 2026

OpenAI

Playground

ภาพรวม

คุณสมบัติสำคัญ

การสร้างแบบหลายโมดัล (วิดีโอ + เสียง) — Sora-2-Pro สร้างเฟรมวิดีโอพร้อมเสียงที่ซิงโครไนซ์ (บทสนทนา เสียงบรรยากาศ SFX) แทนการผลิตวิดีโอและเสียงแยกกัน
ความเที่ยงตรงสูง / ระดับ “Pro” — ปรับจูนเพื่อให้ได้ ความเที่ยงตรงด้านภาพที่สูงกว่า รับมือช็อตที่ยาก (การเคลื่อนไหวซับซ้อน การบังกัน และปฏิสัมพันธ์ทางกายภาพ) และคงความสม่ำเสมอต่อฉากได้นานกว่า Sora-2 (non-Pro) อาจใช้เวลาสร้างผลลัพธ์นานกว่ารุ่นมาตรฐาน Sora-2
ความยืดหยุ่นของอินพุต — รองรับพรอมต์แบบข้อความล้วน และรับเฟรมภาพอินพุตหรือภาพอ้างอิงเพื่อกำหนดองค์ประกอบ (เวิร์กโฟลว์ input_reference)
Cameos / likeness injection — สามารถแทรกภาพเหมือนของผู้ใช้ที่บันทึกไว้ลงในฉากที่สร้างขึ้น โดยใช้เวิร์กโฟลว์การให้ความยินยอมในแอป
ความสมจริงทางกายภาพ: ปรับปรุงการคงอยู่ของวัตถุและความเที่ยงตรงของการเคลื่อนไหว (เช่น โมเมนตัม แรงลอยตัว) ลดอาร์ติแฟกต์แบบ “teleporting” ที่ไม่สมจริงซึ่งพบได้บ่อยในระบบรุ่นก่อน
การควบคุมได้: รองรับพรอมต์แบบมีโครงสร้างและคำสั่งระดับช็อต เพื่อให้ผู้สร้างระบุการตั้งค่ากล้อง แสง และลำดับหลายช็อตได้

รายละเอียดเชิงเทคนิคและพื้นที่การผสานรวม

พารามิเตอร์ทั่วไป:

model: "sora-2-pro"
prompt: คำอธิบายฉากแบบภาษาธรรมชาติ อาจใส่บทสนทนาด้วยก็ได้
seconds / duration: ความยาวคลิปเป้าหมาย (Pro รองรับคุณภาพสูงสุดภายในช่วงความยาวที่มีให้)
size / resolution: รายงานจากชุมชนระบุว่า Pro รองรับได้สูงสุดถึง 1080p ในหลายกรณีการใช้งาน

ประสิทธิภาพตามเกณฑ์

ข้อจำกัด (เชิงปฏิบัติ & ความปลอดภัย)

ฟิสิกส์/ความสม่ำเสมอไม่สมบูรณ์แบบ — แม้ดีขึ้นแต่ยังอาจมีอาร์ติแฟกต์ การเคลื่อนไหวไม่เป็นธรรมชาติ หรือความคลาดเคลื่อนการซิงค์เสียง
ข้อจำกัดด้านความยาวและคอมพิวต์ — คลิปยาวต้องใช้ทรัพยากรมาก; เวิร์กโฟลว์จำนวนมากจึงจำกัดความยาวคลิปให้สั้น (เช่น หลักไม่กี่วินาทีถึงหลักสิบวินาที สำหรับคุณภาพสูง)
ความเป็นส่วนตัว/ความยินยอม — likeness injection (“cameos”) มีความเสี่ยงด้านความยินยอมและข้อมูลเท็จ; OpenAI มีการควบคุมด้านความปลอดภัยและกลไกเพิกถอนในแอป แต่ต้องผสานอย่างมีความรับผิดชอบ
ต้นทุน & ระยะหน่วง — การเรนเดอร์คุณภาพ Pro มีค่าใช้จ่ายและช้ากว่าโมเดลที่เบากว่า/คู่แข่ง; ควรคำนึงถึงการคิดค่าบริการต่อวินาที/ต่อการเรนเดอร์และการเข้าคิว
การกรองด้านความปลอดภัยของเนื้อหา — จำกัดการสร้างเนื้อหาที่เป็นอันตรายหรือมีลิขสิทธิ์; โมเดลและแพลตฟอร์มมีเลเยอร์ความปลอดภัยและการกลั่นกรอง

กรณีใช้งานทั่วไปและที่แนะนำ

กรณีใช้งาน:

การตลาด & ต้นแบบโฆษณา — สร้างงานต้นแบบเชิงภาพยนตร์อย่างรวดเร็ว
พรีวิชวลไลเซชัน — สตอรีบอร์ด การวางกล้อง การดูภาพช็อต
คอนเทนต์สั้นสำหรับโซเชียล — คลิปสไตล์ต่างๆ พร้อมบทสนทนาและเอฟเฟกต์เสียงที่ซิงค์กัน
วิธีเข้าถึง Sora 2 Pro API

ขั้นตอนที่ 1: ลงทะเบียนเพื่อรับ API Key

cometapi-key

ขั้นตอนที่ 2: ส่งคำขอไปยัง Sora 2 Pro API

ขั้นตอนที่ 3: ดึงและยืนยันผลลัพธ์

การฝึกภายใน/การจำลอง — สร้างภาพสถานการณ์สำหรับงานวิจัย RL หรือโรบอติกส์ (ด้วยความระมัดระวัง)
งานโปรดักชันเชิงสร้างสรรค์ — เมื่อนำไปต่อยอดด้วยการตัดต่อของมนุษย์ (ต่อคลิปสั้นๆ เกรดดิ้ง แทนที่เสียง)

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

ราคา

ทดสอบ 5 วินาที

$1.20

ค่าใช้จ่ายโดยประมาณของ CometAPI

ทดสอบ 10 วินาที

$2.40

ค่าใช้จ่ายโดยประมาณของ CometAPI

ทดสอบ 15 วินาที

$3.60

ค่าใช้จ่ายโดยประมาณของ CometAPI

ราคาสำหรับ Sora 2 Pro

Model Name	Tags	Orientation	Resolution	Price
sora-2-pro	videos	Portrait	720x1280	$0.24 / sec
sora-2-pro	videos	Landscape	1280x720	$0.24 / sec
sora-2-pro	videos	Portrait (High Res)	1024x1792	$0.40 / sec
sora-2-pro	videos	Landscape (High Res)	1792x1024	$0.40 / sec
sora-2-pro-all	-	Universal / All	-	$0.80000

API

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

POST/v1/videos

โค้ดตัวอย่างและ API สำหรับ Sora 2 Pro

POST

/v1/videos

# Create a video with sora-2-pro
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=sora-2-pro" \
  -F "prompt=A calico cat playing a piano on stage")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '
' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")

  # Parse progress from "progress": "0%" format
  progress=$(echo "$status_response" | grep -o '"progress":"[^"]*"' | head -1 | sed 's/"progress":"//;s/"$//')
  # Parse status from the outer level
  status=$(echo "$status_response" | grep -o '"status":"[^"]*"' | head -1 | sed 's/"status":"//;s/"$//')

  echo "Progress: $progress, Status: $status"

  if [ "$progress" = "100%" ]; then
    echo "Video generation completed!"
    break
  fi

  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ]; then
    echo "Video generation failed!"
    echo "$status_response"
    exit 1
  fi

  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

cURL Code Example

# Create a video with sora-2-pro
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=sora-2-pro" \
  -F "prompt=A calico cat playing a piano on stage")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '\n' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")
  
  # Parse progress from "progress": "0%" format
  progress=$(echo "$status_response" | grep -o '"progress":"[^"]*"' | head -1 | sed 's/"progress":"//;s/"$//')
  # Parse status from the outer level
  status=$(echo "$status_response" | grep -o '"status":"[^"]*"' | head -1 | sed 's/"status":"//;s/"$//')
  
  echo "Progress: $progress, Status: $status"
  
  if [ "$progress" = "100%" ]; then
    echo "Video generation completed!"
    break
  fi
  
  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ]; then
    echo "Video generation failed!"
    echo "$status_response"
    exit 1
  fi
  
  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

Python Code Example

# Create a video with sora-2-pro using raw HTTP requests
import os
import time
import requests

api_key = os.environ.get("COMETAPI_KEY")
base_url = "https://api.cometapi.com/v1"

headers = {"Authorization": f"Bearer {api_key}"}

# Step 1: Submit the video generation request
print("Submitting video generation request...")
response = requests.post(
    f"{base_url}/videos",
    headers=headers,
    files={
        "model": (None, "sora-2-pro"),
        "prompt": (None, "A calico cat playing a piano on stage"),
    },
)

result = response.json()
print(f"Response: {result}")

video_id = result.get("id")
print(f"Video ID: {video_id}")

# Step 2: Poll for progress until 100%
print("\nChecking video generation progress...")
while True:
    try:
        status_response = requests.get(f"{base_url}/videos/{video_id}", headers=headers)
        status_result = status_response.json()

        # Parse progress and status from response
        data = status_result.get("data", {})
        if data is None:
            data = {}
        progress = data.get("progress", "0%")
        status = data.get("status", "unknown")

        print(f"Progress: {progress}, Status: {status}")

        if status in ["FAILURE", "failed"]:
            print("Video generation failed!")
            print(status_result)
            exit(1)

        if progress == "100%":
            print("Video generation completed!")
            break
    except Exception as e:
        print(f"Temporary error: {e}, retrying...")

    time.sleep(10)

# Step 3: Download the video to output directory
print(f"\nDownloading video to ./output/{video_id}.mp4...")
os.makedirs("./output", exist_ok=True)

video_response = requests.get(f"{base_url}/videos/{video_id}/content", headers=headers)

output_path = f"./output/{video_id}.mp4"
with open(output_path, "wb") as f:
    f.write(video_response.content)

if os.path.exists(output_path):
    file_size = os.path.getsize(output_path)
    print(f"Video saved to {output_path}")
    print(f"File size: {file_size} bytes")
else:
    print("Failed to download video")
    exit(1)

JavaScript Code Example

// Create a video with sora-2-pro using raw HTTP requests
import fs from "fs";
import path from "path";

const apiKey = process.env.COMETAPI_KEY;
const baseUrl = "https://api.cometapi.com/v1";

async function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function main() {
  // Step 1: Submit the video generation request
  console.log("Submitting video generation request...");

  const formData = new FormData();
  formData.append("model", "sora-2-pro");
  formData.append("prompt", "A calico cat playing a piano on stage");

  const submitResponse = await fetch(`${baseUrl}/videos`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
    body: formData,
  });

  const result = await submitResponse.json();
  console.log("Response:", JSON.stringify(result, null, 2));

  const videoId = result.id;
  console.log("Video ID:", videoId);

  // Step 2: Poll for progress until 100%
  console.log("\nChecking video generation progress...");

  while (true) {
    try {
      const statusResponse = await fetch(`${baseUrl}/videos/${videoId}`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
      });

      const text = await statusResponse.text();
      if (text.startsWith("<")) {
        console.log("Temporary server error, retrying...");
        await sleep(10000);
        continue;
      }

      const statusResult = JSON.parse(text);

      // Parse progress and status from response
      const data = statusResult.data || {};
      const progress = data.progress || "0%";
      const status = data.status || "unknown";

      console.log(`Progress: ${progress}, Status: ${status}`);

      if (status === "FAILURE" || status === "failed") {
        console.log("Video generation failed!");
        console.log(JSON.stringify(statusResult, null, 2));
        process.exit(1);
      }

      if (progress === "100%") {
        console.log("Video generation completed!");
        break;
      }
    } catch (e) {
      console.log(`Temporary error: ${e.message}, retrying...`);
    }

    await sleep(10000);
  }

  // Step 3: Download the video to output directory
  console.log(`\nDownloading video to ./output/${videoId}.mp4...`);

  const outputDir = "./output";
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  const videoResponse = await fetch(`${baseUrl}/videos/${videoId}/content`, {
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
  });

  const outputPath = path.join(outputDir, `${videoId}.mp4`);
  const videoBuffer = Buffer.from(await videoResponse.arrayBuffer());
  fs.writeFileSync(outputPath, videoBuffer);

  if (fs.existsSync(outputPath)) {
    const stats = fs.statSync(outputPath);
    console.log(`Video saved to ${outputPath}`);
    console.log(`File size: ${stats.size} bytes`);
  } else {
    console.log("Failed to download video");
    process.exit(1);
  }
}

main().catch(console.error);