Doubao-Seedance-2-0

Q: Does Seedance 2.0 allow editing and extension of existing videos?

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

ต่อวินาที:$0.08

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

ใหม่

ใช้งานเชิงพาณิชย์

ภาพรวม

คุณสมบัติ

ราคา

API

เวอร์ชัน

ข้อกำหนดทางเทคนิคของ Doubao Seedance 2.0

รายการ	รายละเอียด
ตระกูลผลิตภัณฑ์	ตระกูลการสร้างวิดีโอ ByteDance Seedance
Slug ของ CometAPI	doubao-seedance-2-0
ผู้ให้บริการ	ByteDance / BytePlus ModelArk
ประเภทโมเดล	โมเดลสร้างวิดีโอ
รูปแบบอินพุต	ข้อความ, ภาพ, เสียง, วิดีโอ
ความจุการอ้างอิง	สูงสุด 9 ภาพ, คลิปวิดีโอ 3 คลิป และคลิปเสียง 3 คลิปในคำขอมัลติโหมดเดียว
ชนิดเอาต์พุต	วิดีโอ MP4
ความละเอียดเอาต์พุต	480p, 720p, 1080p
อัตราส่วนภาพ	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
ระยะเวลาเอาต์พุต	4–15 วินาที
รูปแบบ API	การสร้างวิดีโอแบบอะซิงโครนัสที่ขับเคลื่อนด้วยงาน

Doubao Seedance 2.0 คืออะไร?

Doubao Seedance 2.0 คือโมเดลสร้างวิดีโอมัลติโหมดเรือธงของ ByteDance (เปิดตัวกุมภาพันธ์ 2026) ใช้สถาปัตยกรรมการสร้างร่วมภาพ–เสียงแบบบูรณาการที่เปิดให้ควบคุมระดับผู้กำกับได้อย่างแม่นยำ โดยอ้างอิงภาพหลายภาพ คลิปวิดีโอ และไฟล์เสียงพร้อมกัน โดดเด่นในการสร้างวิดีโอเชิงภาพยนตร์ที่การเคลื่อนไหวเสถียร พร้อมซิงก์เสียงแบบเนทีฟ เหมาะสำหรับครีเอเตอร์มืออาชีพที่ต้องการฟิสิกส์สมจริง ความคงเส้นคงวาของตัวละคร และการจัดองค์ประกอบฉากที่ซับซ้อน

คุณสมบัติหลักของ Doubao Seedance 2.0 บน CometAPI

การสร้างแบบมัลติโหมดแบบรวมเป็นหนึ่ง: รองรับอินพุตข้อความ ภาพ เสียง และวิดีโอในเวิร์กโฟลว์เดียว ผู้ใช้จึงสามารถกำกับฉากด้วยข้อมูลอ้างอิงที่หลากหลายกว่าเครื่องมือที่ใช้ข้อความอย่างเดียว
การควบคุมสไตล์ผู้กำกับ: โมเดลถูกสร้างมาเพื่อทำตามพรอมป์ตด้านการแสดง แสง เงา การเคลื่อนกล้อง จังหวะการเคลื่อนไหว และลักษณะเสียง
ตัดต่อวิดีโอและขยายความยาว: ไม่ได้จำกัดแค่การสร้างครั้งแรก รองรับการแก้ไขคลิป ตัวละคร การกระทำ และเส้นเรื่องเฉพาะ รวมถึงการขยายต่อไปข้างหน้า/ย้อนกลับ
การซิงก์ภาพ–เสียงที่แข็งแกร่ง: ByteDance เน้นเอาต์พุตสเตอริโอ 2 แชนแนล และการซิงก์ระหว่างดนตรีประกอบ เสียงบรรยากาศ และพฤติกรรมของเสียงบรรยาย เพื่อผลลัพธ์ที่ดื่มด่ำยิ่งขึ้น
ความสามารถในการควบคุมสูงสำหรับฉากซับซ้อน: ปรับปรุงการจัดการปฏิสัมพันธ์ที่ซับซ้อน ฉากเคลื่อนไหว และความสมเหตุสมผลทางฟิสิกส์ เมื่อเทียบกับ Seedance 1.5
เอาต์พุตเชิงการผลิต: API รองรับการกำหนดค่าอัตราส่วน ระยะเวลา และวอเตอร์มาร์ก ทำให้โมเดลใช้งานได้จริงในเวิร์กโฟลว์คอนเทนต์ที่ทำซ้ำได้

ผลการทดสอบมาตรฐาน

ByteDance ระบุว่า Seedance 2.0 ใช้มาตรวัดภายในชื่อ SeedVideoBench-2.0 และอยู่ในระดับแถวหน้าทั้งโจทย์ข้อความสู่วิดีโอ ภาพสู่วิดีโอ และงานมัลติโหมด โมเดลนี้ยกระดับคุณภาพการสร้าง ความถูกต้องทางฟิสิกส์ ความสมจริง และความสามารถในการควบคุมเหนือกว่า Seedance 1.5 โดยเฉพาะในฉากที่มีปฏิสัมพันธ์และการเคลื่อนไหวซับซ้อน

โหมด Seedance 2.0 API และ Seedance 2.0 Fast API บน CometAPI

โมเดล	ชื่อโมเดลใน CometAPI	เหมาะสำหรับ	ความแตกต่างหลัก
Seedance 2.0	doubao-seedance-2-0	การสร้างวิดีโอมัลติโหมดคุณภาพสูงสุด	สแต็กอ้างอิงที่กว้างที่สุดและความสามารถในการควบคุมที่แข็งแกร่งที่สุดในตระกูล Seedance 2.0
Seedance 2.0 fast	doubao-seedance-2-0-fast	ผลิตได้เร็วขึ้นเมื่อยอมแลกคุณภาพเล็กน้อย	ByteDance ระบุว่าคงความสามารถของโมเดลเช่นเดียวกับ Seedance 2.0 แต่สร้างได้เร็วกว่า
Seedance 1.5 Pro	doubao-seedance-1-5-pro	การสร้างภาพ–เสียงรุ่นก่อน	Seedance 1.5 Pro ถูกวางตำแหน่งเป็นโมเดลภาพ–เสียงแบบเนทีฟ ขณะที่ Seedance 2.0 ขยายสแต็กการอ้างอิงมัลติโหมดและการตัดต่อให้กว้างขึ้น

จุดเด่นเมื่อเทียบกับคู่แข่ง:

เทียบกับ Kling 3.0: ควบคุมการอ้างอิงมัลติโหมดและเสียงแบบเนทีฟได้ดีกว่า
เทียบกับ Sora 2: ความแม่นยำในการอ้างอิงและความสามารถแบบหลายช็อตเหนือกว่า ระยะเวลาสูงสุดต่ำกว่านิดหน่อย
เทียบกับ Veo 3.1: แข็งแรงกว่าในด้านความสม่ำเสมอของตัวละครและการทำตามพรอมป์ตสำหรับงานที่พึ่งพาการอ้างอิงจำนวนมาก; Veo เด่นกว่าด้านเกรดภาพยนตร์ดิบและคลิปที่ยาวกว่า

โดดเด่นในวิดีโอที่เน้นมนุษย์และขับเคลื่อนด้วยการแสดง

ทดลองใช้ Seedance 2.0 AI Video Generator บน CometAPI

ขั้นตอนที่ 1: ขั้นตอนที่ 1: สมัครรับ API Key

เริ่มต้นได้ทันทีใน CometAPI Playground เพื่อสัมผัส Doubao Seedance 2.0 โดยไม่ต้องตั้งค่าหรือเขียนโค้ด เพียงเข้าสู่ระบบบัญชี CometAPI ของคุณ ไปที่หน้ารายละเอียดโมเดล doubao-seedance-2-0 อัปโหลดภาพอ้างอิง คลิปวิดีโอสั้น หรือไฟล์เสียง เพิ่มพรอมป์ตเชิงบรรยาย แล้วสร้างวิดีโอตัวอย่างได้ทันที นี่คือวิธีที่เร็วที่สุดในการทำความเข้าใจว่า Seedance 2.0 จัดการความคงที่ของการเคลื่อนไหว รูปลักษณ์ตัวละคร การเคลื่อนกล้อง และการซิงก์เสียงแบบเนทีฟอย่างไร

ขั้นตอนที่ 2: ขอรับการเข้าถึง API สำหรับ Seedance 2.0 บน CometAPI

สร้างหรือใช้ CometAPI key ที่มีอยู่เพื่อเปิดการเข้าถึงเต็มรูปแบบสำหรับ Doubao Seedance 2.0 หลังจากเข้าสู่ระบบ ให้ไปที่ส่วน API Token ในคอนโซล สร้างคีย์ใหม่และคัดลอก จากนั้นไปที่หน้ารายละเอียดโมเดล Seedance 2.0 และ เอกสาร API บน CometAPI เพื่อทบทวนพารามิเตอร์ที่รองรับสำหรับการผนวกรวมเข้ากับโปรเจกต์ของคุณ

ขั้นตอนที่ 3: ส่งคำขอแรกของคุณด้วย Seedance 2.0 API

ใช้เอ็นด์พอยต์ของ CometAPI เพื่อส่งคำขอสร้างวิดีโอครั้งแรก พร้อมพรอมป์ตข้อความที่ชัดเจนและไฟล์อ้างอิงตัวเลือก (ภาพ วิดีโอ หรือเสียง) ระบบจะประมวลผลงานแบบอะซิงโครนัส ส่งคืน task ID และมอบวิดีโอ MP4 ที่ดาวน์โหลดได้เมื่อเสร็จสิ้น จากนั้นคุณสามารถปรับแต่งพรอมป์ต ปรับการตั้งค่า และขยายสเกลสำหรับวิดีโอมาร์เก็ตติ้ง คอนเทนต์โซเชียลมีเดีย ไปป์ไลน์วิดีโออัตโนมัติ หรือแอปพลิเคชันเชิงสร้างสรรค์ที่ขับเคลื่อนด้วย Seedance 2.0

เวิร์กโฟลว์นี้ช่วยให้คุณทดลองอย่างรวดเร็วใน playground และเปลี่ยนผ่านสู่การใช้งานจริงผ่าน CometAPI ได้อย่างราบรื่น

เหตุผลหลักในการเลือกใช้ Seedance 2.0 บน CometAPI

ทำไมจึงใช้ CometAPI สำหรับ Seedance 2.0

เข้าถึงได้โดยตรงผ่าน API หรือ Playground
ควบคุมพารามิเตอร์ได้ง่าย (ระยะเวลา ความละเอียด รูปแบบ)
รองรับทั้งเวิร์กโฟลว์ ข้อความสู่วิดีโอ และ ภาพสู่วิดีโอ
มีระบบจัดการงานในตัวสำหรับการสร้างวิดีโอแบบอะซิงโครนัส

API แบบรวมและเป็นมิตรกับนักพัฒนา

CometAPI มีเอ็นด์พอยต์ที่สะอาดและมาตรฐาน ทำงานร่วมกับรูปแบบสไตล์ OpenAI หรือเอ็นด์พอยต์งานวิดีโอเฉพาะทางได้อย่างไร้รอยต่อ คุณจะได้รับการสร้างงาน การโพลลิง และการดาวน์โหลด MP4 ที่ตรงไปตรงมา โดยไม่ต้องยุ่งกับการยืนยันตัวตนที่ซับซ้อนของ Volcengine หรือข้อจำกัดด้านภูมิภาค

ราคาคุ้มค่า

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

ทดสอบได้รวดเร็วด้วย Playground

ทดลองได้ทันทีใน CometAPI Playground อัปโหลดภาพ วิดีโอ และไฟล์เสียงอ้างอิง ปรับแต่งพรอมป์ต และดูตัวอย่างผลลัพธ์ในไม่กี่นาที เหมาะอย่างยิ่งสำหรับการวนลองสไตล์ จังหวะการเคลื่อนไหว และการซิงก์เสียง ก่อนเข้าสู่การผลิตจริง

โดยสรุป, หากคุณต้องการพลังสร้างสรรค์ของ Seedance 2.0 — การควบคุมการอ้างอิงระดับแถวหน้า การเคลื่อนไหวเป็นธรรมชาติ และเสียงแบบเนทีฟ — โดยไม่ต้องยุ่งยากกับการเข้าถึง ByteDance โดยตรง, CometAPI เป็นหนึ่งในแพลตฟอร์มที่ดีที่สุดในตอนนี้ สำหรับการใช้งานมัน

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

What kinds of inputs does Seedance 2.0 support for video generation?

Seedance 2.0 รองรับอินพุตแบบมัลติโหมด ได้แก่ พรอมต์ข้อความ ภาพได้สูงสุด 9 ภาพ คลิปวิดีโอสั้นได้สูงสุด 3 คลิป และไฟล์เสียงได้สูงสุด 3 ไฟล์ ซึ่งสามารถผสมกันได้อย่างอิสระเพื่อการสร้างสรรค์ที่หลากหลายและควบคุมได้

Can Seedance 2.0 maintain character and style consistency across multiple video shots?

ใช่ — Seedance 2.0 ถูกออกแบบมาสำหรับการเล่าเรื่องแบบหลายชอตที่สอดคล้องกลมกลืน โดยรักษาความคงเส้นคงวาของตัวละคร สไตล์ภาพ และบรรยากาศระหว่างฉาก เพื่อลดปัญหาการเพี้ยนของวิดีโอ AI ที่พบบ่อย

What outputs and quality levels can I expect from Seedance 2.0 videos?

Seedance 2.0 สามารถสร้างวิดีโอระดับภาพยนตร์ (ความละเอียดสูงสุด 2K) พร้อมเสียงในตัว บทสนทนาที่ซิงก์กัน และการสังเคราะห์การเคลื่อนไหวอย่างเป็นธรรมชาติ โดยปกติเป็นคลิปยาว 5–60 วินาที

How does Seedance 2.0 handle audio and lip synchronization?

โมเดลสร้างเสียงและวิดีโอร่วมกัน ทำให้ได้การซิงก์ภาพ-เสียงแบบเนทีฟ พร้อมการซิงก์การขยับปากในระดับโฟนีมใน 8+ ภาษา เพื่อให้คำพูดและเอฟเฟกต์เสียงเป็นธรรมชาติ.

Is Seedance 2.0 suitable for professional creative projects like marketing or narrative shorts?

ใช่ — การควบคุมแบบมัลติโหมด ความต่อเนื่องหลายชอต และผลลัพธ์ความเที่ยงตรงสูงของ Seedance 2.0 ทำให้เหมาะสำหรับวิดีโอมาร์เก็ตติ้ง หนังสั้นเชิงเล่าเรื่อง โฆษณา และการใช้งานระดับมืออาชีพอื่นๆ.

How do referencing assets (images, video clips) work in Seedance 2.0 prompts?

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

Does Seedance 2.0 allow editing and extension of existing videos?

What are known limitations or typical generation lengths with Seedance 2.0?

ความยาวผลลัพธ์โดยทั่วไปอยู่ที่ประมาณ ~5 ถึง ~60 วินาทีต่อวิดีโอ และการรวมสินทรัพย์จำนวนมากหรือเลือกความละเอียดสูงอาจทำให้เวลาในการสร้างเพิ่มขึ้น

คุณสมบัติสำหรับ Doubao-Seedance-2-0

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

ราคาสำหรับ Doubao-Seedance-2-0

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

doubao-seedance Video Generation Pricing

Parameters

Parameter	Description
Duration (seconds)	4–15 seconds, default 5 seconds
Aspect Ratio (size)	`21:9` / `16:9` / `4:3` / `1:1` / `3:4` / `9:16`, default `16:9`
Resolution	`480p` / `720p` / `1080p`*, default `720p`

*1080p only available for doubao-seedance-1-5-pro and doubao-seedance-1-0-pro

Pricing (Per Second)

Model	480p	720p	1080p
`doubao-seedance-2-0`	$0.08	$0.24	—
`doubao-seedance-2-0-fast`	$0.064	$0.192	—
`doubao-seedance-1-5-pro`	$0.018	$0.04147	$0.09331
`doubao-seedance-1-0-pro`	$0.01875	$0.0432	$0.0972

💡 Billed per second. Total cost = price per second × video duration (seconds). Duration range: 4–15 seconds.

โค้ดตัวอย่างและ API สำหรับ Doubao-Seedance-2-0

เข้าถึงโค้ดตัวอย่างที่ครอบคลุมและทรัพยากร API สำหรับ Doubao-Seedance-2-0 เพื่อปรับปรุงกระบวนการผสานรวมของคุณ เอกสารประกอบที่มีรายละเอียดของเราให้คำแนะนำทีละขั้นตอน ช่วยให้คุณใช้ประโยชน์จากศักยภาพเต็มรูปแบบของ Doubao-Seedance-2-0 ในโครงการของคุณ

POST

/v1/videos

Python
JavaScript
Curl

import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}

def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False

def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600

def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")

def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

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

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
        "resolution": (None, "720p"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

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

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

Python Code Example

import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}


def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False


def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600


def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")


def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

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

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
        "resolution": (None, "720p"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

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

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

JavaScript Code Example

import fs from "fs";
import path from "path";

// Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
const api_key = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const base_url = "https://api.cometapi.com";
const output_dir = "./output";
const poll_interval_ms = 10_000;
const retry_delay_ms = 5_000;
const max_create_attempts = 5;
const max_query_attempts = 3;
const terminal_statuses = new Set(["success", "completed", "failed", "error"]);
const success_statuses = new Set(["success", "completed"]);

function is_progress_complete(progress) {
  if (typeof progress === "number") {
    return progress >= 100;
  }

  if (typeof progress === "string") {
    const numeric = Number(progress.replace(/%$/, ""));
    return Number.isFinite(numeric) && numeric >= 100;
  }

  return false;
}

function is_transient_status(status) {
  return status === 429 || status >= 500;
}

async function fetch_with_retry(url, options, attempts, label) {
  for (let attempt = 1; attempt <= attempts; attempt += 1) {
    const response = await fetch(url, options);
    if (response.ok) {
      return response;
    }

    if (!is_transient_status(response.status) || attempt === attempts) {
      return response;
    }

    console.log(`${label} returned ${response.status}, retrying...`);
    await new Promise((resolve) => setTimeout(resolve, retry_delay_ms));
  }

  throw new Error(`${label} failed`);
}

if (api_key === "<YOUR_COMETAPI_KEY>") {
  console.log("Set COMETAPI_KEY before running this example.");
  process.exit(0);
}

const headers = {
  Authorization: `Bearer ${api_key}`,
};

const form = new FormData();
form.set("prompt", "A slow cinematic camera push across a coastal landscape at sunrise.");
form.set("model", "doubao-seedance-2-0");
form.set("seconds", "5");
form.set("size", "16:9");
form.set("resolution", "720p");

const create_response = await fetch_with_retry(`${base_url}/v1/videos`, {
  method: "POST",
  headers,
  body: form,
}, max_create_attempts, "Create request");

if (!create_response.ok) {
  console.log(await create_response.text());
  process.exit(1);
}

const create_result = await create_response.json();
const task_id = create_result.id || create_result.task_id;

if (!task_id) {
  console.log(JSON.stringify(create_result, null, 2));
  process.exit(1);
}

console.log(`Task created: ${task_id}`);
console.log(`Initial status: ${create_result.status}`);

while (true) {
  const task_response = await fetch_with_retry(`${base_url}/v1/videos/${task_id}`, {
    headers,
  }, max_query_attempts, "Status request");

  if (!task_response.ok) {
    console.log(await task_response.text());
    process.exit(1);
  }

  const task = await task_response.json();
  const status = String(task.status || "unknown");
  const normalized_status = status.toLowerCase();
  const progress = task.progress;
  const should_try_download = success_statuses.has(normalized_status) || (
    normalized_status === "unknown" && is_progress_complete(progress)
  );

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

  if (should_try_download || terminal_statuses.has(normalized_status)) {
    if (should_try_download) {
      const video_url = task.video_url || "";
      const content_url = `${base_url}/v1/videos/${task_id}/content`;
      const output_path = path.join(output_dir, `${task_id}.mp4`);

      if (!fs.existsSync(output_dir)) {
        fs.mkdirSync(output_dir, { recursive: true });
      }

      const video_response = await fetch(content_url, { headers });
      if (!video_response.ok) {
        console.log(await video_response.text());
        process.exit(1);
      }

      const video_buffer = Buffer.from(await video_response.arrayBuffer());
      fs.writeFileSync(output_path, video_buffer);

      console.log(`Video URL: ${video_url}`);
      console.log(`Content endpoint: ${content_url}`);
      console.log(`Saved to ${output_path}`);
      console.log(`File size: ${fs.statSync(output_path).size} bytes`);
    } else {
      console.log(JSON.stringify(task, null, 2));
      process.exit(1);
    }
    break;
  }

  await new Promise((resolve) => setTimeout(resolve, poll_interval_ms));
}

Curl Code Example

#!/bin/bash

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

if [[ -z "${COMETAPI_KEY:-}" ]]; then
  echo "Set COMETAPI_KEY before running this example."
  exit 0
fi

BASE_URL="https://api.cometapi.com"
OUTPUT_DIR="./output"
POLL_INTERVAL_SECONDS=10
RETRY_DELAY_SECONDS=5
MAX_CREATE_ATTEMPTS=5
MAX_QUERY_ATTEMPTS=3

is_progress_complete() {
  local progress="$1"
  local normalized="${progress%%%}"

  if [[ -z "$normalized" ]]; then
    return 1
  fi

  [[ "$normalized" =~ ^[0-9]+([.][0-9]+)?$ ]] || return 1
  awk -v value="$normalized" 'BEGIN { exit !(value >= 100) }'
}

create_task() {
  local attempt=1
  while (( attempt <= MAX_CREATE_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos" \
      -H "Authorization: Bearer $COMETAPI_KEY" \
      -F 'prompt="A slow cinematic camera push across a coastal landscape at sunrise."' \
      -F 'model="doubao-seedance-2-0"' \
      -F 'seconds="5"' \
      -F 'size="16:9"' \
      -F 'resolution="720p"')

    status_code=$(echo "$response" | tail -n 1)
    CREATE_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_CREATE_ATTEMPTS )); then
      echo "Create request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$CREATE_RESPONSE"
    return 1
  done
}

get_task() {
  local task_id="$1"
  local attempt=1
  while (( attempt <= MAX_QUERY_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos/${task_id}" \
      -H "Authorization: Bearer $COMETAPI_KEY")

    status_code=$(echo "$response" | tail -n 1)
    TASK_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_QUERY_ATTEMPTS )); then
      echo "Status request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$TASK_RESPONSE"
    return 1
  done
}

create_task

TASK_ID=$(echo "$CREATE_RESPONSE" | jq -r '.id // .task_id // empty')

if [[ -z "$TASK_ID" ]]; then
  echo "$CREATE_RESPONSE" | jq .
  echo "No task id returned."
  exit 1
fi

echo "Task created: $TASK_ID"
echo "Initial status: $(echo "$CREATE_RESPONSE" | jq -r '.status // empty')"

while true; do
  get_task "$TASK_ID"

  STATUS=$(echo "$TASK_RESPONSE" | jq -r '.status // empty')
  NORMALIZED_STATUS=$(echo "$STATUS" | tr '[:upper:]' '[:lower:]')
  PROGRESS=$(echo "$TASK_RESPONSE" | jq -r '.progress // empty')
  SHOULD_TRY_DOWNLOAD=0

  if [[ "$NORMALIZED_STATUS" == "success" || "$NORMALIZED_STATUS" == "completed" ]]; then
    SHOULD_TRY_DOWNLOAD=1
  elif [[ "$NORMALIZED_STATUS" == "unknown" ]] && is_progress_complete "$PROGRESS"; then
    SHOULD_TRY_DOWNLOAD=1
  fi

  echo "Status: ${STATUS}, progress: ${PROGRESS}"

  if [[ "$SHOULD_TRY_DOWNLOAD" == "1" || "$NORMALIZED_STATUS" == "failed" || "$NORMALIZED_STATUS" == "error" ]]; then
    if [[ "$SHOULD_TRY_DOWNLOAD" == "1" ]]; then
      VIDEO_URL=$(echo "$TASK_RESPONSE" | jq -r '.video_url // empty')
      CONTENT_URL="${BASE_URL}/v1/videos/${TASK_ID}/content"
      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "$CONTENT_URL" \
        -H "Authorization: Bearer $COMETAPI_KEY" \
        -o "$OUTPUT_PATH"

      if [[ ! -s "$OUTPUT_PATH" ]]; then
        echo "Failed to download video"
        exit 1
      fi

      echo "Video URL: ${VIDEO_URL}"
      echo "Content endpoint: ${CONTENT_URL}"
      echo "Saved to ${OUTPUT_PATH}"
      echo "File size: $(wc -c < "$OUTPUT_PATH" | tr -d ' ') bytes"
    else
      echo "$TASK_RESPONSE" | jq .
      exit 1
    fi
    break
  fi

  sleep "$POLL_INTERVAL_SECONDS"
done

รุ่นของ Doubao-Seedance-2-0

เหตุผลที่ Doubao-Seedance-2-0 มีสแนปช็อตหลายตัวอาจรวมถึงปัจจัยที่อาจเกิดขึ้น เช่น ความแปรผันของผลลัพธ์หลังการอัปเดตที่ต้องการสแนปช็อตรุ่นเก่าสำหรับความสม่ำเสมอ การให้ช่วงเวลาเปลี่ยนผ่านสำหรับนักพัฒนาเพื่อการปรับตัวและการย้ายข้อมูล และสแนปช็อตที่แตกต่างกันซึ่งสอดคล้องกับเอนด์พอยต์ระดับโลกหรือระดับภูมิภาคเพื่อเพิ่มประสิทธิภาพประสบการณ์ผู้ใช้ สำหรับความแตกต่างโดยละเอียดระหว่างเวอร์ชัน โปรดอ้างอิงเอกสารทางการ

version
doubao-seedance-2-0
doubao-seedance-2-0-fast

โมเดลเพิ่มเติม

บล็อกที่เกี่ยวข้อง

Apr 17, 2026

วิธีใช้ Seedance 2.0 API

Seedance 2.0 API คือโมเดลสร้างวิดีโอ AI แบบมัลติโมดัลรุ่นล่าสุดจาก ByteDance (เปิดตัวเมื่อ 9 เมษายน 2026). รองรับการส่งข้อความ รูปภาพ คลิปวิดีโอ และเสียงในคำขอเดียว เพื่อสร้างวิดีโอ MP4 ความยาว 4–15 วินาทีในสไตล์ภาพยนตร์ พร้อมการซิงค์เสียงแบบเนทีฟ การควบคุมกล้องระดับผู้กำกับ และความสม่ำเสมอของการเคลื่อนไหวที่โดดเด่น. วิธีใช้งาน: ลงทะเบียนที่ CometAPI.com, ขอรับ API key, ส่งงานแบบ async ผ่าน REST, poll เพื่อตรวจสอบการเสร็จสิ้น, และดาวน์โหลดวิดีโอจาก URL.

Apr 11, 2026

HappyHorse-1.0 คืออะไร? จะเปรียบเทียบ Seedance 2.0 อย่างไร?

เรียนรู้ว่า HappyHorse-1.0 คืออะไร เหตุใดจึงขึ้นอันดับหนึ่งบนลีดเดอร์บอร์ดวิดีโอของ Artificial Analysis เปรียบเทียบกับ Seedance 2.0 อย่างไร และการจัดอันดับล่าสุดมีความหมายอย่างไรต่อการสร้างวิดีโอด้วย AI

Mar 24, 2026

Seedance 2.0 คืออะไร? การวิเคราะห์อย่างครอบคลุม

Seedance 2.0 เป็นโมเดล AI สร้างวิดีโอแบบมัลติโมดัลยุคถัดไปที่พัฒนาโดย ByteDance สามารถสร้างวิดีโอคุณภาพสูงระดับภาพยนตร์จากข้อความ รูปภาพ เสียง และวิดีโออ้างอิงได้ โดดเด่นด้วยการสร้างภาพและเสียงร่วมกัน ความเสถียรของการเคลื่อนไหว และการตัดต่อแบบอ้างอิง อีกทั้งยังไต่แรงก์ในเบนช์มาร์กระดับโลกอย่างรวดเร็ว เช่น ตารางจัดอันดับ Artificial Analysis ส่งให้เป็นหนึ่งในโมเดลวิดีโอ AI ชั้นนำในปี 2026