Doubao-Seedance-2-0

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

Seedance 2.0 obsługuje multimodalne wejścia, w tym prompty tekstowe, do 9 obrazów, do 3 krótkich klipów wideo oraz do 3 plików audio, które można swobodnie łączyć, aby uzyskać bogate, kontrolowalne generowanie.

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

Tak — Seedance 2.0 jest zaprojektowany do spójnego, wieloujęciowego opowiadania historii z konsekwentnymi postaciami, stylem wizualnym i atmosferą między scenami, ograniczając typowe problemy dryfu wideo AI.

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

Seedance 2.0 może generować filmy klasy kinowej (do rozdzielczości 2K) z natywnym dźwiękiem, zsynchronizowanymi dialogami i naturalną syntezą ruchu, zwykle w klipach trwających 5–60 sekund.

Q: How does Seedance 2.0 handle audio and lip synchronization?

Model generuje dźwięk i obraz wspólnie, oferując natywną synchronizację audio-wideo z synchronizacją ust na poziomie fonemów w 8+ językach, co zapewnia naturalną mowę i efekty dźwiękowe.

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

Tak — multimodalna kontrola, ciągłość między ujęciami i wysoka wierność wyjścia Seedance 2.0 sprawiają, że nadaje się do filmów marketingowych, krótkich form narracyjnych, reklam i innych profesjonalnych zastosowań.

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

Użytkownicy mogą przesyłać zasoby referencyjne, a następnie w języku naturalnym opisać, jak każdy z nich powinien wpływać na ruch, ruch kamery lub elementy stylistyczne, zapewniając precyzyjną kontrolę nad generowanymi treściami.

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

Tak — model obsługuje rozszerzanie wideo i ukierunkowaną edycję, taką jak dodawanie scen, zastępowanie postaci lub modyfikowanie określonych segmentów przy zachowaniu nieedytowanych części.

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

Typowe długości wyników mieszczą się w zakresie od ~5 do ~60 sekund na wideo, a łączenie wielu zasobów lub ustawienia wysokiej rozdzielczości mogą wydłużyć czas generowania.

Na Sekundę:$0.08

Seedance 2.0 to nowej generacji multimodalny model bazowy dla wideo firmy ByteDance, skoncentrowany na generowaniu filmowych, wieloujęciowych narracyjnych materiałów wideo. W odróżnieniu od jednoujęciowych demonstracji typu tekst‑do‑wideo, Seedance 2.0 kładzie nacisk na kontrolę opartą na materiałach referencyjnych (obrazy, krótkie klipy, audio), spójność postaci i stylu między ujęciami oraz natywną synchronizację audio/wideo — dążąc do tego, by wideo AI było użyteczne w profesjonalnych procesach twórczych i prewizualizacji.

Nowy

Użycie komercyjne

Przegląd

Funkcje

Cennik

API

Wersje

Specyfikacja techniczna Doubao Seedance 2.0

Pozycja	Szczegóły
Rodzina produktu	ByteDance Seedance – rodzina modeli generowania wideo
CometAPI slug	doubao-seedance-2-0
Dostawca	ByteDance / BytePlus ModelArk
Typ modelu	Model generowania wideo
Modalności wejściowe	Tekst, obraz, audio, wideo
Pojemność odniesień	Do 9 obrazów, 3 klipów wideo i 3 klipów audio w jednym żądaniu multimodalnym
Typ wyjścia	Wideo MP4
Rozdzielczość wyjściowa	480p, 720p, 1080p
Proporcje obrazu	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Czas trwania materiału wyjściowego	4–15 sekund
Styl API	Asynchroniczne generowanie wideo oparte na zadaniach

Czym jest Doubao Seedance 2.0?

Doubao Seedance 2.0 to flagowy, multimodalny model generowania wideo firmy ByteDance (wydany w lutym 2026 r.). Wykorzystuje ujednoliconą architekturę wspólnego generowania audio-wideo, która umożliwia precyzyjną, reżyserską kontrolę dzięki jednoczesnemu odwoływaniu się do wielu obrazów, klipów wideo i plików audio. Doskonale sprawdza się w tworzeniu filmowych, stabilnych ruchowo materiałów z natywną synchronizacją audio — idealnych dla profesjonalnych twórców potrzebujących realistycznej fizyki, spójnych postaci i złożonej kompozycji scen.

Najważniejsze funkcje Doubao Seedance 2.0 w CometAPI

Ujednolicone generowanie multimodalne: Akceptuje wejścia tekstowe, obrazowe, audio i wideo w jednym przepływie, dzięki czemu użytkownicy mogą reżyserować scenę, korzystając z bogatszych materiałów referencyjnych niż w generatorach wyłącznie tekstowych.
Kontrola w stylu reżyserskim: Model został zaprojektowany tak, aby podążać za wskazówkami dotyczącymi ekspresji, oświetlenia, cieni, ruchu kamery, rytmu ruchu i charakteru dźwięku.
Edycja i rozszerzanie wideo: Seedance 2.0 nie ogranicza się do pierwszego przebiegu generowania; obsługuje edytowanie konkretnych klipów, postaci, akcji i wątków fabularnych, a także rozszerzanie w przód i wstecz.
Silna synchronizacja audiowizualna: ByteDance podkreśla dwukanałowe wyjście stereo oraz synchronizację muzyki w tle, dźwięków otoczenia i zachowania lektora dla bardziej immersyjnych rezultatów.
Wysoka sterowalność złożonych scen: Lepsza obsługa złożonych interakcji, scen ruchu i zgodności fizycznej w porównaniu z Seedance 1.5.
Produkcja zorientowana na wynik: API obsługuje konfigurowalne proporcje, czas trwania i znaki wodne, co czyni model praktycznym w powtarzalnych przepływach tworzenia treści.

Wyniki benchmarków

ByteDance podaje, że Seedance 2.0 wykorzystuje wewnętrzną ocenę SeedVideoBench-2.0 i plasuje się w czołówce w zadaniach text-to-video, image-to-video oraz multimodalnych. Model poprawia jakość generowania, zgodność z fizyką, realizm i sterowalność względem Seedance 1.5, szczególnie w złożonych interakcjach i scenach ruchu.

Tryby Seedance 2.0 API i Seedance 2.0 Fast API w CometAPI

Model	Nazwa modelu w CometAPI	Najlepiej nadaje się do	Główna różnica
Seedance 2.0	doubao-seedance-2-0	Najwyższej jakości multimodalne tworzenie wideo	Najszerszy zestaw materiałów referencyjnych i najsilniejsza kontrolowalność w rodzinie Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Szybsza produkcja, gdy można nieco poświęcić jakość	ByteDance twierdzi, że zachowuje te same możliwości modelu co Seedance 2.0, ale generuje szybciej.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Tworzenie audio-wideo poprzedniej generacji	Seedance 1.5 Pro jest pozycjonowany jako rodzimy, wspólny model audio-wideo, natomiast Seedance 2.0 rozszerza zestaw odniesień i możliwości edycyjne.

Mocne strony na tle konkurencji:

vs Kling 3.0: Lepsza kontrola odniesień multimodalnych i natywne audio.
vs Sora 2: Lepsza precyzja odniesień i możliwość tworzenia wielokadrowych ujęć; nieco niższy maksymalny czas trwania.
vs Veo 3.1: Silniejsza spójność postaci i zgodność z poleceniami w przepływach intensywnie korzystających z odniesień; Veo prowadzi w zakresie czystego gradingu kinowego i dłuższych klipów.

Świetnie sprawdza się w materiałach zorientowanych na ludzi i wykonanie.

Wypróbuj generator wideo Seedance 2.0 AI w CometAPI

Krok 1: Krok 1: Zarejestruj klucz API

Rozpocznij bezpośrednio w CometAPI Playground, aby doświadczyć Doubao Seedance 2.0 bez konfiguracji i kodowania. Zaloguj się do swojego konta CometAPI, przejdź do strony modelu doubao-seedance-2-0, prześlij obrazy referencyjne, krótkie klipy wideo lub pliki audio, dodaj opisowy prompt i generuj podglądowe wideo natychmiast. To najszybszy sposób, aby zrozumieć, jak Seedance 2.0 radzi sobie ze spójnością ruchu, wyglądem postaci, ruchem kamery i natywną synchronizacją audio.

Krok 2: Uzyskaj dostęp do API Seedance 2.0 w CometAPI

Utwórz lub użyj istniejącego klucza CometAPI, aby uzyskać pełny dostęp do Doubao Seedance 2.0. Po zalogowaniu przejdź do sekcji API Token na swoim koncie, wygeneruj nowy klucz i skopiuj go. Następnie odwiedź stronę modelu Seedance 2.0 oraz Dokumentacja API w CometAPI, aby przejrzeć obsługiwane parametry integracji w Twoich projektach.

Krok 3: Wyślij pierwsze żądanie do Seedance 2.0 API

Użyj endpointu CometAPI, aby przesłać pierwsze żądanie generowania wideo z jasnym poleceniem tekstowym i opcjonalnymi plikami referencyjnymi (obrazy, wideo lub audio). System przetworzy zadanie asynchronicznie, zwróci identyfikator zadania i udostępni wideo MP4 do pobrania po zakończeniu. Następnie możesz dopracowywać prompty, dostosowywać ustawienia i skalować działania na potrzeby wideo marketingowych, treści w mediach społecznościowych, zautomatyzowanych potoków wideo lub kreatywnych zastosowań zasilanych przez Seedance 2.0.

Ten przepływ zapewnia szybkie eksperymenty w playgroundzie i płynne przejście do zastosowań produkcyjnych poprzez CometAPI.

Najważniejsze powody, aby wybrać Seedance 2.0 w CometAPI

Dlaczego korzystać z CometAPI dla Seedance 2.0

Bezpośredni dostęp przez API lub Playground
Łatwa kontrola parametrów (czas trwania, rozdzielczość, format)
Obsługa zarówno przepływów text-to-video, jak i image-to-video
Wbudowana obsługa zadań dla asynchronicznego generowania wideo

Ujednolicone i przyjazne deweloperom API

CometAPI oferuje przejrzysty, znormalizowany endpoint, który bezproblemowo współpracuje ze znanymi formatami w stylu OpenAI lub dedykowanymi endpointami zadań wideo. Otrzymujesz prostą kreację zadań, odpytywanie oraz pobieranie plików MP4 bez konieczności mierzenia się ze skomplikowaną autoryzacją Volcengine ani ograniczeniami regionalnymi.

Korzystne ceny

CometAPI zazwyczaj oferuje bardziej konkurencyjne stawki za sekundę w porównaniu z dostawcami bezpośrednimi, co pozwala generować wysokiej jakości wideo na skalę — do marketingu, mediów społecznościowych czy zautomatyzowanych potoków — bez nadmiernych kosztów.

Szybkie testy w Playground

Eksperymentuj od razu w CometAPI Playground. Przesyłaj obrazy, wideo i audio referencyjne, dopracowuj prompty i podglądaj wyniki w kilka minut — idealne do iteracji nad stylem, ruchem i synchronizacją audio, zanim przejdziesz do produkcji.

Krótko mówiąc, jeśli chcesz mocy twórczej Seedance 2.0 — najlepszej w swojej klasie kontroli odniesień, naturalnego ruchu i natywnego audio — bez kłopotów związanych z bezpośrednim dostępem do ByteDance, CometAPI jest obecnie jedną z najlepszych platform, aby z niego korzystać.

FAQ

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

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

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

How does Seedance 2.0 handle audio and lip synchronization?

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

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?

Cennik dla Doubao-Seedance-2-0

Poznaj konkurencyjne ceny dla Doubao-Seedance-2-0, zaprojektowane tak, aby pasowały do różnych budżetów i potrzeb użytkowania. Nasze elastyczne plany zapewniają, że płacisz tylko za to, czego używasz, co ułatwia skalowanie w miarę wzrostu Twoich wymagań. Odkryj, jak Doubao-Seedance-2-0 może ulepszyć Twoje projekty przy jednoczesnym utrzymaniu kosztów na rozsądnym poziomie.

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.

Przykładowy kod i API dla Doubao-Seedance-2-0

Uzyskaj dostęp do kompleksowego przykładowego kodu i zasobów API dla Doubao-Seedance-2-0, aby usprawnić proces integracji. Nasza szczegółowa dokumentacja zapewnia wskazówki krok po kroku, pomagając wykorzystać pełny potencjał Doubao-Seedance-2-0 w Twoich projektach.

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

Wersje modelu Doubao-Seedance-2-0

Powody, dla których Doubao-Seedance-2-0 posiada wiele migawek, mogą obejmować takie czynniki jak: różnice w wynikach po aktualizacjach wymagające starszych migawek dla zachowania spójności, zapewnienie programistom okresu przejściowego na adaptację i migrację, oraz różne migawki odpowiadające globalnym lub regionalnym punktom końcowym w celu optymalizacji doświadczenia użytkownika. Aby poznać szczegółowe różnice między wersjami, zapoznaj się z oficjalną dokumentacją.

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

Więcej modeli

Powiązane blogi

Apr 17, 2026

Jak korzystać z interfejsu API Seedance 2.0

Seedance 2.0 API to najnowszy multimodalny model generowania wideo AI firmy ByteDance (uruchomiony 9 kwietnia 2026 r.). Akceptuje tekst, obrazy, klipy wideo i audio w jednym żądaniu, aby tworzyć filmowe materiały wideo MP4 o długości 4–15 sekund z natywną synchronizacją audio, kontrolą kamery na poziomie reżyserskim oraz wyjątkową spójnością ruchu. Aby z niego skorzystać: zarejestruj się na CometAPI.com, uzyskaj klucz API, wyślij asynchroniczne zadanie za pośrednictwem interfejsu REST, odpytywaj pod kątem ukończenia i pobierz wideo z podanego adresu URL.

Apr 11, 2026

Czym jest HappyHorse-1.0? Jak porównać Seedance 2.0?

Dowiedz się, czym jest HappyHorse-1.0, dlaczego zajął pierwsze miejsce w rankingu wideo Artificial Analysis, jak wypada w porównaniu z Seedance 2.0 oraz co najnowsze rankingi oznaczają dla generowania wideo przez AI.

Mar 24, 2026

Czym jest Seedance 2.0? Kompleksowa analiza

Seedance 2.0 to nowej generacji wielomodalny model AI do generowania wideo opracowany przez ByteDance, który potrafi tworzyć wysokiej jakości, filmowe materiały wideo na podstawie tekstu, obrazów, dźwięku i nagrań referencyjnych. Oferuje łączone generowanie audio-wideo, stabilność ruchu oraz edycję opartą na materiałach referencyjnych, a także szybko pnie się w światowych benchmarkach, takich jak ranking Artificial Analysis, plasując się w 2026 roku wśród czołowych modeli wideo AI.