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

Seedance 2.0 supports multimodal inputs including text prompts, up to 9 images, up to 3 short video clips, and up to 3 audio files, which can be freely combined for rich, controllable generation.

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

Yes — Seedance 2.0 is designed for coherent multi-shot storytelling with consistent characters, visual style, and atmosphere across scenes, reducing common AI video drift issues.

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

Seedance 2.0 can generate cinematic-grade videos (up to 2K resolution) with native audio, synchronized dialogue, and natural motion synthesis, typically in clips of 5–60 seconds.

How does Seedance 2.0 handle audio and lip synchronization?

The model generates audio and video jointly, offering native audio-visual sync with phoneme-level lip sync in 8+ languages for natural speech and sound effects.

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

Yes — Seedance 2.0’s multimodal control, multi-shot continuity, and high fidelity output make it suitable for marketing videos, narrative shorts, ads, and other professional applications.

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

Users can upload reference assets and then describe in natural language how each should influence motion, camera movement, or stylistic elements, giving fine-grained control over the generated content.

Does Seedance 2.0 allow editing and extension of existing videos?

Yes — the model supports video extension and targeted editing like adding scenes, replacing characters, or altering specific segments while preserving unedited portions.

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

Typical output lengths range from ~5 to ~60 seconds per video, and combining many assets or high-resolution settings can increase generation time.

Kimi K3 is now live on CometAPI →

Seedance 2-0

Mỗi Giây:$0.056

Ngày phát hành:Apr 19, 2026

Seedance 2.0 là mô hình nền tảng video đa phương thức thế hệ mới của ByteDance, tập trung vào khả năng tạo video kể chuyện đa cảnh mang phong cách điện ảnh. Khác với các bản demo chuyển văn bản thành video chỉ một cảnh, Seedance 2.0 nhấn mạnh điều khiển dựa trên tham chiếu (hình ảnh, clip ngắn, âm thanh), đảm bảo tính nhất quán mạch lạc về nhân vật và phong cách xuyên suốt các cảnh quay, cùng khả năng đồng bộ âm thanh–hình ảnh ở mức gốc — nhằm khiến video AI trở nên hữu ích cho các quy trình sáng tạo chuyên nghiệp và tiền trực quan hóa.

Mới

Phổ biến

Sử dụng thương mại

Playground cho Seedance 2-0

Khám phá Playground của Seedance 2-0 — môi trường tương tác để kiểm tra mô hình và chạy truy vấn theo thời gian thực. Thử prompts, điều chỉnh tham số và lặp lại ngay lập tức để tăng tốc phát triển và xác thực các trường hợp sử dụng.

Thông số kỹ thuật của Doubao Seedance 2.0

Hạng mục	Chi tiết
Dòng sản phẩm	Dòng tạo video Seedance của ByteDance
Slug trên CometAPI	doubao-seedance-2-0
Nhà cung cấp	ByteDance / BytePlus ModelArk
Loại mô hình	Mô hình tạo video
Hình thức đầu vào	Văn bản, hình ảnh
Loại đầu ra	Video MP4
Độ phân giải đầu ra	480p, 720p, 1080p
Tỷ lệ khung hình	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Thời lượng đầu ra	4–15 giây
Kiểu API	Tạo video dạng tác vụ bất đồng bộ

Doubao Seedance 2.0 là gì?

Doubao Seedance 2.0 là mô hình tạo video đa phương thức hàng đầu của ByteDance (phát hành tháng 2 năm 2026). Nó sử dụng kiến trúc tạo đồng thời âm thanh–video thống nhất, cho phép điều khiển chính xác ở cấp độ đạo diễn bằng cách tham chiếu đồng thời nhiều hình ảnh, đoạn video và tệp âm thanh. Mô hình xuất sắc trong việc tạo ra các video điện ảnh ổn định chuyển động với đồng bộ âm thanh gốc — lý tưởng cho nhà sáng tạo chuyên nghiệp cần vật lý chân thực, nhân vật nhất quán và bố cục cảnh phức tạp.

Các tính năng chính của Doubao Seedance 2.0 trên CometAPI

Tạo đa phương thức thống nhất: Chấp nhận đầu vào văn bản, hình ảnh, âm thanh và video trong một quy trình, giúp người dùng đạo diễn cảnh với tư liệu tham chiếu phong phú hơn so với chỉ văn bản.
Điều khiển phong cách đạo diễn: Mô hình được xây dựng để tuân theo prompt về diễn xuất, ánh sáng, đổ bóng, chuyển động camera, nhịp chuyển động và đặc tính âm thanh.
Chỉnh sửa và mở rộng video: Seedance 2.0 không chỉ tạo lần đầu; nó hỗ trợ chỉnh sửa các đoạn, nhân vật, hành động và tuyến truyện cụ thể, cùng mở rộng tiến/lùi.
Đồng bộ nghe nhìn mạnh mẽ: ByteDance nhấn mạnh đầu ra âm thanh nổi hai kênh và sự đồng bộ giữa nhạc nền, âm thanh môi trường và hành vi lồng tiếng để mang lại trải nghiệm đắm chìm hơn.
Khả năng điều khiển cao cho cảnh phức tạp: Nhấn mạnh cải thiện xử lý tương tác phức tạp, cảnh chuyển động và tính hợp lý vật lý so với Seedance 1.5.
Đầu ra định hướng sản xuất: API hỗ trợ cấu hình tỷ lệ, thời lượng và cài đặt watermark, giúp mô hình thực tiễn cho quy trình nội dung lặp lại.

Hiệu năng theo điểm chuẩn

ByteDance cho biết Seedance 2.0 sử dụng bộ đánh giá nội bộ SeedVideoBench-2.0 và đứng ở vị trí dẫn đầu trên các chiều nhiệm vụ text-to-video, image-to-video và đa phương thức. Mô hình cải thiện chất lượng sinh, độ chính xác vật lý, tính chân thực và khả năng điều khiển so với Seedance 1.5, đặc biệt ở các tương tác phức tạp và cảnh chuyển động.

Chế độ API Seedance 2.0 và Seedance 2.0 Fast trên CometAPI

Mô hình	Tên mô hình trên CometAPI	Phù hợp nhất cho	Khác biệt chính
Seedance 2.0	doubao-seedance-2-0	Tạo video đa phương thức chất lượng cao nhất	Ngăn xếp tham chiếu rộng nhất và khả năng điều khiển mạnh nhất trong họ Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Sản xuất nhanh hơn khi có thể đánh đổi một chút chất lượng	ByteDance cho biết giữ nguyên khả năng của Seedance 2.0 nhưng tạo nhanh hơn.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Tạo âm thanh–video thế hệ trước	Seedance 1.5 Pro được định vị là mô hình âm thanh–video đồng thời gốc, trong khi Seedance 2.0 mở rộng ngăn xếp tham chiếu và chỉnh sửa đa phương thức.

Điểm mạnh so với đối thủ:

so với Kling 3.0: Kiểm soát tham chiếu đa phương thức và âm thanh gốc tốt hơn.
so với Sora 2: Độ chính xác tham chiếu và khả năng multi-shot vượt trội; thời lượng tối đa thấp hơn một chút.
so với Veo 3.1: Mạnh hơn về tính nhất quán nhân vật và tuân thủ prompt cho quy trình nặng tham chiếu; Veo dẫn trước ở chất điện ảnh thô và clip dài hơn.

Xuất sắc trong các video lấy con người làm trung tâm và dựa trên trình diễn.

Dùng thử Seedance 2.0 AI Video Generator trên CometAPI

Step 1: Step 1: Đăng ký API Key

Bắt đầu trực tiếp trong CometAPI Playground để trải nghiệm Doubao Seedance 2.0 mà không cần thiết lập hay viết mã. Chỉ cần đăng nhập tài khoản CometAPI, vào trang mô hình doubao-seedance-2-0, tải lên ảnh tham chiếu, clip video ngắn hoặc tệp âm thanh, thêm prompt mô tả và tạo video xem trước ngay lập tức. Đây là cách nhanh nhất để hiểu cách Seedance 2.0 xử lý tính nhất quán chuyển động, ngoại hình nhân vật, chuyển động camera và đồng bộ âm thanh gốc.

Step 2: Nhận quyền truy cập API cho Seedance 2.0 trên CometAPI

Tạo hoặc dùng CometAPI key hiện có để bật quyền truy cập đầy đủ vào Doubao Seedance 2.0. Sau khi đăng nhập, đi tới mục API Token trong console, tạo key mới và sao chép. Sau đó truy cập trang chi tiết mô hình Seedance 2.0 và Tài liệu API trên CometAPI để xem các tham số hỗ trợ khi tích hợp vào dự án.

Step 3: Gửi yêu cầu đầu tiên với Seedance 2.0 API

Sử dụng endpoint của CometAPI để gửi yêu cầu tạo video đầu tiên với prompt văn bản rõ ràng và tệp tham chiếu tùy chọn (hình ảnh, video hoặc âm thanh). Hệ thống sẽ xử lý tác vụ bất đồng bộ, trả về ID tác vụ và cung cấp video MP4 có thể tải xuống khi hoàn tất. Sau đó bạn có thể tinh chỉnh prompt, điều chỉnh thiết lập và mở rộng cho video marketing, nội dung mạng xã hội, pipeline video tự động hoặc các ứng dụng sáng tạo vận hành bởi Seedance 2.0.

Quy trình này giúp bạn thử nghiệm nhanh trong playground và chuyển mượt sang sử dụng sản xuất qua CometAPI.

Những lý do hàng đầu để chọn Seedance 2.0 trên CometAPI

Vì sao dùng CometAPI cho Seedance 2.0

Truy cập trực tiếp qua API hoặc Playground
Dễ điều khiển tham số (thời lượng, độ phân giải, định dạng)
Hỗ trợ cả quy trình text-to-video và image-to-video
Xử lý tác vụ tích hợp sẵn cho tạo video bất đồng bộ

API thống nhất và thân thiện với nhà phát triển

CometAPI cung cấp endpoint sạch, tiêu chuẩn hóa, hoạt động mượt với định dạng kiểu OpenAI hoặc các endpoint tác vụ video chuyên dụng. Bạn có thao tác tạo tác vụ, polling và tải MP4 đơn giản mà không phải xử lý xác thực phức tạp của Volcengine hoặc các hạn chế theo khu vực.

Giá cả hiệu quả về chi phí

CometAPI thường đưa ra mức giá theo giây cạnh tranh hơn so với nhà cung cấp trực tiếp, cho phép bạn tạo video chất lượng cao ở quy mô lớn cho marketing, mạng xã hội hoặc pipeline tự động mà không vượt ngân sách.

Thử nghiệm nhanh với Playground

Thử nghiệm ngay trong CometAPI Playground. Tải lên ảnh, video và tệp âm thanh tham chiếu, tinh chỉnh prompt và xem trước kết quả trong vài phút — hoàn hảo để lặp nhanh về phong cách, chuyển động và đồng bộ âm thanh trước khi vào sản xuất.

Tóm lại, nếu bạn muốn sức mạnh sáng tạo của Seedance 2.0 — kiểm soát tham chiếu hàng đầu, chuyển động tự nhiên và âm thanh gốc — mà không cần phiền toái khi truy cập trực tiếp ByteDance, CometAPI hiện là một trong những nền tảng tốt nhất để sử dụng nó.

Câu Hỏi Thường Gặp

Giá cả cho Seedance 2-0

Khám phá mức giá cạnh tranh cho Seedance 2-0, được thiết kế để phù hợp với nhiều ngân sách và nhu cầu sử dụng khác nhau. Các gói linh hoạt của chúng tôi đảm bảo bạn chỉ trả tiền cho những gì bạn sử dụng, giúp dễ dàng mở rộng quy mô khi yêu cầu của bạn tăng lên. Khám phá cách Seedance 2-0 có thể nâng cao các dự án của bạn trong khi vẫn kiểm soát được chi phí.

doubao-seedance Video Generation Pricing

Parameters

Parameter	Description
Duration (seconds)	4–15 seconds, default 5 seconds
size	Refer to documentation

*1080p is available for all models except doubao-seedance-2-0-fast

Pricing (Per Second)

Model	480p	720p	1080p	4k
`doubao-seedance-2-0`	$0.056	$0.1216	$0.2992	$0.624
`doubao-seedance-2-0-fast`	$0.0448	$0.096	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—
`doubao-seedance-1-0-pro`	$0.0192	$0.0416	$0.0976	—
`doubao-seedance-1-0-pro-fast`	$0.008	$0.016	$0.0384	—

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

Mã mẫu và API cho Seedance 2-0

Truy cập mã mẫu toàn diện và tài nguyên API cho Seedance 2-0 để tối ưu hóa quy trình tích hợp của bạn. Tài liệu chi tiết của chúng tôi cung cấp hướng dẫn từng bước, giúp bạn khai thác toàn bộ tiềm năng của Seedance 2-0 trong các dự án của mình.

POST

/v1/videos

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"),
    }
)
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"),
    }
)
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");

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"')

    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

Các phiên bản của Seedance 2-0

Lý do Seedance 2-0 có nhiều snapshot có thể bao gồm các yếu tố tiềm năng như: sự thay đổi đầu ra sau các bản cập nhật cần các snapshot cũ để đảm bảo tính nhất quán, cung cấp cho nhà phát triển thời gian chuyển tiếp để thích ứng và di chuyển, cũng như các snapshot khác nhau tương ứng với các endpoint toàn cầu hoặc khu vực nhằm tối ưu hóa trải nghiệm người dùng. Để biết chi tiết về sự khác biệt giữa các phiên bản, vui lòng tham khảo tài liệu chính thức.

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