Jak Seedance 2.0 radzi sobie z synchronizacją audio i ruchu warg?

Model generuje dźwięk i obraz łącznie, oferując natywną synchronizację audiowizualną z synchronizacją ruchu warg na poziomie fonemów w 8+ językach dla naturalnej mowy i efektów dźwiękowych.

Czy Seedance 2.0 umożliwia edycję i rozszerzanie istniejących filmów?

Tak — model obsługuje rozszerzanie wideo i ukierunkowaną edycję, taką jak dodawanie scen, zastępowanie postaci lub modyfikowanie konkretnych fragmentów z zachowaniem nieedytowanych części.

Jakie typy danych wejściowych obsługuje Seedance 2.0 do generowania wideo?

Seedance 2.0 obsługuje wejścia multimodalne, w tym polecenia tekstowe, do 9 obrazów, do 3 krótkich klipów wideo oraz do 3 plików audio, które można dowolnie łączyć w celu bogatego, kontrolowalnego generowania.

Jakich wyników i poziomów jakości mogę oczekiwać od wideo generowanych przez Seedance 2.0?

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

Jakie są znane ograniczenia lub typowe długości generowanych materiałów w Seedance 2.0?

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

Jak działają zasoby referencyjne (obrazy, klipy wideo) w poleceniach Seedance 2.0?

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, co daje precyzyjną kontrolę nad generowaną treścią.

Czy Seedance 2.0 potrafi utrzymać spójność postaci i stylu w wielu ujęciach wideo?

Tak — Seedance 2.0 został zaprojektowany do spójnego opowiadania historii w wielu ujęciach, z konsekwentnymi postaciami, stylem wizualnym i atmosferą między scenami, co ogranicza typowe problemy dryfu w wideo AI.

Czy Seedance 2.0 nadaje się do profesjonalnych projektów kreatywnych, takich jak marketing lub krótkie formy fabularne?

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

Bytedance

Dostępny Popularny

doubao-seedance-2-0

Seedance 2-0 API

Seedance 2.0 to następnej generacji multimodalny bazowy model wideo firmy ByteDance, skoncentrowany na generowaniu kinowych, wieloujęciowych narracyjnych materiałów wideo. W odróżnieniu od jednoujęciowych demonstracji text-to-video, 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ę dźwięku i obrazu — dążąc do tego, by wideo AI było użyteczne w profesjonalnych procesach twórczych i prewizualizacyjnych.

Cena początkowa

$0.056 / sekundę

Rozliczenie za zużycie

Stan API

Dostępny

Endpoint produkcyjny

Czas odpowiedzi

Gotowe na async

Zaobserwowany czas odpowiedzi API

Data wydania

Apr 19, 2026

Bytedance

Playground

Wypróbuj Seedance 2-0 z rzeczywistym żądaniem, sprawdź jego parametry i zweryfikuj wynik przed integracją API.

Przegląd

Praktyczny przegląd Seedance 2-0, obejmujący ważne zachowania i uwagi dotyczące integracji.

Specyfikacja techniczna Doubao Seedance 2.0

Element	Szczegóły
Rodzina produktu	rodzina generowania wideo Seedance firmy ByteDance
Slug w CometAPI	doubao-seedance-2-0
Dostawca	ByteDance / BytePlus ModelArk
Typ modelu	model generowania wideo
Modalności wejściowe	tekst, obraz
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 wyjściowy	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 zunifikowaną architekturę wspólnego generowania audio‑wideo, która umożliwia precyzyjną, reżyserską kontrolę poprzez jednoczesne odwoływanie się do wielu obrazów, klipów wideo i plików audio. Wyróżnia się tworzeniem filmowych, stabilnych ruchowo ujęć z natywną synchronizacją dźwięku — idealny 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 na CometAPI

Ujednolicone generowanie multimodalne: Akceptuje wejścia tekstowe, obrazowe, audio i wideo w jednym przepływie pracy, dzięki czemu użytkownicy mogą reżyserować scenę z bogatszym materiałem referencyjnym niż w generatorach opartych wyłącznie na tekście.
Kontrola w stylu reżyserskim: Model został zbudowany tak, by podążać za promptami dotyczącymi gry aktorskiej, oświetlenia, cieni, ruchów kamery, rytmu ruchu i charakterystyki dźwięku.
Edycja i rozszerzanie wideo: Seedance 2.0 nie ogranicza się do pierwszego przebiegu generowania; obsługuje edycję konkretnych klipów, postaci, działań i wątków fabularnych oraz rozszerzanie do przodu i do tyłu.
Silna synchronizacja audiowizualna: ByteDance podkreśla wyjście stereo dwukanałowe oraz zsynchronizowane tło muzyczne, dźwięki otoczenia i narrację głosową, co zapewnia bardziej immersyjne efekty.
Wysoka sterowalność w złożonych scenach: Podkreśla ulepszoną obsługę złożonych interakcji, scen z ruchem i wiarygodności fizycznej w porównaniu z Seedance 1.5.
Wyjście zorientowane na produkcję: API obsługuje konfigurowalne proporcje, czas trwania i znak wodny, co czyni model praktycznym w powtarzalnych przepływach tworzenia treści.

Wyniki benchmarków

ByteDance informuje, że Seedance 2.0 używa wewnętrznej oceny SeedVideoBench-2.0 i plasuje się w czołówce w zadaniach text‑to‑video, image‑to‑video i multimodalnych. Model poprawia jakość generowania, dokładność fizyczną, realizm i sterowalność względem Seedance 1.5, zwłaszcza w scenach złożonych interakcji i ruchu.

Tryby Seedance 2.0 API i Seedance 2.0 Fast API w CometAPI

Model	Nazwa modelu w CometAPI	Najlepsze zastosowanie	Główna różnica
Seedance 2.0	doubao-seedance-2-0	tworzenie multimodalnych wideo najwyższej jakości	Najszerszy zestaw referencji i największa sterowalność 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 podaje, że zachowuje takie same możliwości modelu jak Seedance 2.0, ale generuje szybciej.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	tworzenie audio‑wideo wcześniejszej generacji	Seedance 1.5 Pro jest pozycjonowany jako natywny wspólny model audio‑wideo, podczas gdy Seedance 2.0 rozszerza multimodalny stos referencji i edycji.

Mocne strony na tle konkurentów:

vs Kling 3.0: Lepsza kontrola nad multimodalnymi referencjami i natywnym dźwiękiem.
vs Sora 2: Wyższa precyzja referencji i możliwość wieloujęciowa; nieco krótszy maksymalny czas trwania.
vs Veo 3.1: Lepsza spójność postaci i zgodność z promptami w przepływach silnie opartych na referencjach; Veo prowadzi w zakresie surowej gradacji filmowej i dłuższych klipów.

Świetnie sprawdza się w wideo zorientowanych na ludzi i skupionych na performansie.

Wypróbuj generator wideo AI Seedance 2.0 na CometAPI

Krok 1: Krok 1: Zarejestruj się po klucz API

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

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

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

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

Użyj endpointu CometAPI, aby przesłać pierwsze żądanie generowania wideo z klarownym promptem tekstowym i opcjonalnymi plikami referencyjnymi (obrazami, wideo lub audio). System przetworzy zadanie asynchronicznie, zwróci ID zadania i po ukończeniu udostępni wideo MP4 do pobrania. Następnie możesz dopracować prompty, dostosować ustawienia i skalować tworzenie treści do wideo marketingowych, contentu social media, zautomatyzowanych potoków wideo lub kreatywnych zastosowań zasilanych przez Seedance 2.0.

Ten przepływ zapewnia szybkie eksperymentowanie w playgroundzie i płynne przejście do użycia produkcyjnego przez CometAPI.

Najważniejsze powody, by wybrać Seedance 2.0 na CometAPI

Dlaczego warto skorzystać 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 text‑to‑video, jak i image‑to‑video
Wbudowana obsługa zadań dla asynchronicznego generowania wideo

Ujednolicone i przyjazne dla deweloperów API

CometAPI oferuje przejrzysty, znormalizowany endpoint, który działa bezproblemowo z dobrze znanymi formatami w stylu OpenAI lub dedykowanymi endpointami zadań wideo. Otrzymujesz proste tworzenie zadań, odpytywanie i pobieranie MP4 bez zmagania się ze złożoną autoryzacją Volcengine ani ograniczeniami regionalnymi.

Konkurencyjne ceny

CometAPI zazwyczaj oferuje bardziej konkurencyjne stawki za sekundę niż dostawcy bezpośredni, pozwalając generować wysokiej jakości wideo na skalę — do marketingu, social mediów lub zautomatyzowanych potoków — bez nadwyrężania budżetu.

Szybkie testowanie w Playground

Eksperymentuj natychmiast w CometAPI Playground. Przesyłaj referencyjne obrazy, wideo i audio, dopracowuj prompty i podglądaj wyniki w kilka minut — idealne do iteracji nad stylem, ruchem i synchronizacją audio przed wejściem w produkcję.

Krótko mówiąc, jeśli chcesz mocy twórczej Seedance 2.0 — najlepszej w swojej klasie kontroli referencji, naturalnego ruchu i natywnego dźwięku — bez kłopotów z bezpośrednim dostępem do ByteDance, CometAPI jest obecnie jedną z najlepszych platform, by z niego skorzystać.

FAQ

Cennik

Skorzystaj z powyższego szybkiego oszacowania dla pojedynczego uruchomienia, a następnie sprawdź pełne porównanie cen CometAPI i cen oficjalnych.

Test 5 s

$0.28

Szacowany koszt użytkowania CometAPI

Test 10 s

$0.56

Szacowany koszt użytkowania CometAPI

Test 15 s

$0.84

Szacowany koszt użytkowania CometAPI

Cennik dla Seedance 2-0

Poznaj konkurencyjne ceny dla 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 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
size	Refer to documentation

*1080p is unavailable for doubao-seedance-2-0-fast and doubao-seedance-2-0-mini.

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-2-0-mini`	$0.032	$0.064	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—

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

API

Skopiuj działający endpoint i przykładowy kod, a następnie otwórz pełną dokumentację API, gdy potrzebujesz wszystkich parametrów.

Jedno API, dostęp do modeli gotowy do produkcji

Uwierzytelnij się raz, wywołuj endpoint modelu i zachowaj ten sam proces rozliczeń i monitorowania u różnych dostawców.

POST/v1/videos

Przykładowy kod i API dla Seedance 2-0

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

POST

/v1/videos

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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 $'
%{http_code}' "https://api.cometapi.com/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 $'
%{http_code}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

cURL Code Example

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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}' "https://api.cometapi.com/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}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

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

Możliwości

Sprawdź kluczowe informacje o modelu przed wyborem architektury lub oszacowaniem obciążenia produkcyjnego.

Obsługiwane możliwości

Funkcje zwracane przez istniejące API modelu.

text-to-video

image-to-video

Wejście i wyjście

Wejścia

text

Wyjścia

video

Profil produkcyjny

Dostawca: Bytedance
Kontekst: Zależnie od modelu
Użycie komercyjne: Obsługiwane

Przypadki użycia

Używaj Seedance 2-0 w procesach produkcyjnych odpowiadających możliwościom video, a następnie porównaj alternatywy przed długoterminową integracją.

Koncepcje tekst-na-wideo i treści społecznościowe

Dema produktów i kinowe scenariusze obrazkowe

Ruch obraz-na-wideo i kreatywna iteracja

Inne modele

Porównaj inne modele dostępne w CometAPI pod względem jakości, opóźnienia, możliwości i ceny.

Otwórz porównanie modeli →

Aliyun

Wan3.0

From fast verification to cinematic output, billing is based on the generated video duration, selecting the appropriate resolution, and turning every generation into a planned creative investment activity rule

Zobacz model

Flux

Flux 3

FLUX 3 - Real World Models: Towards Multimodal Flow Models as the Backbone of Visual Intelligence.

Zobacz model

Aliyun

Happy Horse 1.1

HappyHorse 1.1 to multimodalny model generowania wideo zaprojektowany z myślą o profesjonalnym tworzeniu treści, reklamie, filmach krótkometrażowych, produkcji na potrzeby mediów społecznościowych oraz opowiadaniu historii. Rozszerza możliwości HappyHorse 1.0—który zyskał znaczną uwagę po uplasowaniu się wysoko w niezależnych ewaluacjach generowania wideo—zapewniając większą spójność scen i poprawioną wierność wizualną.

Zobacz model

Google

Gemini omni fast

Gemini Omni Fast is a lightweight multimodal video generation model designed for fast and flexible content creation. It enables efficient video generation with support for multiple input types, making it suitable for interactive and iterative workflows.

Zobacz model

OpenAI

Sora 2 Pro

Sora 2 Pro to nasz najbardziej zaawansowany i najpotężniejszy model generowania multimediów, zdolny do generowania wideo z zsynchronizowanym dźwiękiem. Może tworzyć szczegółowe, dynamiczne klipy wideo na podstawie języka naturalnego lub obrazów.

Zobacz model

Aliyun

Happy Horse 1.0

Happy Horse 1.0 — A high-quality audio-video generation model that supports text-to-video and image-to-video creation. It can generate synchronized visuals, audio, and lip movements, making it suitable for short films, advertising creatives, and product showcases.

Zobacz model

Uptime

Sprawdź dane heartbeat na żywo, dostępność endpointu i zaobserwowane czasy odpowiedzi przed przejściem do produkcji.

Wersje

Sprawdź dostępne identyfikatory modeli przed ustaleniem integracji produkcyjnej.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Kontynuuj eksplorację

Porównuj modele i kontynuuj swoje badania

Bytedance

Dostępny Popularny

doubao-seedance-2-0

Seedance 2-0 API

Cena początkowa

$0.056 / sekundę

Rozliczenie za zużycie

Stan API

Dostępny

Endpoint produkcyjny

Czas odpowiedzi

Gotowe na async

Zaobserwowany czas odpowiedzi API

Data wydania

Apr 19, 2026

Bytedance

Playground

Wypróbuj Seedance 2-0 z rzeczywistym żądaniem, sprawdź jego parametry i zweryfikuj wynik przed integracją API.

Przegląd

Praktyczny przegląd Seedance 2-0, obejmujący ważne zachowania i uwagi dotyczące integracji.

Specyfikacja techniczna Doubao Seedance 2.0

Element	Szczegóły
Rodzina produktu	rodzina generowania wideo Seedance firmy ByteDance
Slug w CometAPI	doubao-seedance-2-0
Dostawca	ByteDance / BytePlus ModelArk
Typ modelu	model generowania wideo
Modalności wejściowe	tekst, obraz
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 wyjściowy	4–15 sekund
Styl API	asynchroniczne generowanie wideo oparte na zadaniach

Czym jest Doubao Seedance 2.0?

Najważniejsze funkcje Doubao Seedance 2.0 na CometAPI

Ujednolicone generowanie multimodalne: Akceptuje wejścia tekstowe, obrazowe, audio i wideo w jednym przepływie pracy, dzięki czemu użytkownicy mogą reżyserować scenę z bogatszym materiałem referencyjnym niż w generatorach opartych wyłącznie na tekście.
Kontrola w stylu reżyserskim: Model został zbudowany tak, by podążać za promptami dotyczącymi gry aktorskiej, oświetlenia, cieni, ruchów kamery, rytmu ruchu i charakterystyki dźwięku.
Edycja i rozszerzanie wideo: Seedance 2.0 nie ogranicza się do pierwszego przebiegu generowania; obsługuje edycję konkretnych klipów, postaci, działań i wątków fabularnych oraz rozszerzanie do przodu i do tyłu.
Silna synchronizacja audiowizualna: ByteDance podkreśla wyjście stereo dwukanałowe oraz zsynchronizowane tło muzyczne, dźwięki otoczenia i narrację głosową, co zapewnia bardziej immersyjne efekty.
Wysoka sterowalność w złożonych scenach: Podkreśla ulepszoną obsługę złożonych interakcji, scen z ruchem i wiarygodności fizycznej w porównaniu z Seedance 1.5.
Wyjście zorientowane na produkcję: API obsługuje konfigurowalne proporcje, czas trwania i znak wodny, co czyni model praktycznym w powtarzalnych przepływach tworzenia treści.

Wyniki benchmarków

Tryby Seedance 2.0 API i Seedance 2.0 Fast API w CometAPI

Model	Nazwa modelu w CometAPI	Najlepsze zastosowanie	Główna różnica
Seedance 2.0	doubao-seedance-2-0	tworzenie multimodalnych wideo najwyższej jakości	Najszerszy zestaw referencji i największa sterowalność 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 podaje, że zachowuje takie same możliwości modelu jak Seedance 2.0, ale generuje szybciej.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	tworzenie audio‑wideo wcześniejszej generacji	Seedance 1.5 Pro jest pozycjonowany jako natywny wspólny model audio‑wideo, podczas gdy Seedance 2.0 rozszerza multimodalny stos referencji i edycji.

Mocne strony na tle konkurentów:

vs Kling 3.0: Lepsza kontrola nad multimodalnymi referencjami i natywnym dźwiękiem.
vs Sora 2: Wyższa precyzja referencji i możliwość wieloujęciowa; nieco krótszy maksymalny czas trwania.
vs Veo 3.1: Lepsza spójność postaci i zgodność z promptami w przepływach silnie opartych na referencjach; Veo prowadzi w zakresie surowej gradacji filmowej i dłuższych klipów.

Świetnie sprawdza się w wideo zorientowanych na ludzi i skupionych na performansie.

Wypróbuj generator wideo AI Seedance 2.0 na CometAPI

Krok 1: Krok 1: Zarejestruj się po klucz API

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

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

Ten przepływ zapewnia szybkie eksperymentowanie w playgroundzie i płynne przejście do użycia produkcyjnego przez CometAPI.

Najważniejsze powody, by wybrać Seedance 2.0 na CometAPI

Dlaczego warto skorzystać 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 text‑to‑video, jak i image‑to‑video
Wbudowana obsługa zadań dla asynchronicznego generowania wideo

Ujednolicone i przyjazne dla deweloperów API

Konkurencyjne ceny

Szybkie testowanie w Playground

FAQ

Cennik

Skorzystaj z powyższego szybkiego oszacowania dla pojedynczego uruchomienia, a następnie sprawdź pełne porównanie cen CometAPI i cen oficjalnych.

Test 5 s

$0.28

Szacowany koszt użytkowania CometAPI

Test 10 s

$0.56

Szacowany koszt użytkowania CometAPI

Test 15 s

$0.84

Szacowany koszt użytkowania CometAPI

Cennik dla Seedance 2-0

doubao-seedance Video Generation Pricing

Parameters

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

*1080p is unavailable for doubao-seedance-2-0-fast and doubao-seedance-2-0-mini.

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-2-0-mini`	$0.032	$0.064	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—

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

API

Skopiuj działający endpoint i przykładowy kod, a następnie otwórz pełną dokumentację API, gdy potrzebujesz wszystkich parametrów.

Jedno API, dostęp do modeli gotowy do produkcji

Uwierzytelnij się raz, wywołuj endpoint modelu i zachowaj ten sam proces rozliczeń i monitorowania u różnych dostawców.

POST/v1/videos

Przykładowy kod i API dla Seedance 2-0

POST

/v1/videos

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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 $'
%{http_code}' "https://api.cometapi.com/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 $'
%{http_code}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

cURL Code Example

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
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}' "https://api.cometapi.com/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}' "https://api.cometapi.com/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')

      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "https://api.cometapi.com/v1/videos/${TASK_ID}/content" \
        -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: https://api.cometapi.com/v1/videos/${TASK_ID}/content"
      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

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

Możliwości

Sprawdź kluczowe informacje o modelu przed wyborem architektury lub oszacowaniem obciążenia produkcyjnego.

Obsługiwane możliwości

Funkcje zwracane przez istniejące API modelu.

text-to-video

image-to-video

Wejście i wyjście

Wejścia

text

Wyjścia

video

Profil produkcyjny

Dostawca: Bytedance
Kontekst: Zależnie od modelu
Użycie komercyjne: Obsługiwane

Przypadki użycia

Używaj Seedance 2-0 w procesach produkcyjnych odpowiadających możliwościom video, a następnie porównaj alternatywy przed długoterminową integracją.

Koncepcje tekst-na-wideo i treści społecznościowe

Dema produktów i kinowe scenariusze obrazkowe

Ruch obraz-na-wideo i kreatywna iteracja

Inne modele

Porównaj inne modele dostępne w CometAPI pod względem jakości, opóźnienia, możliwości i ceny.

Otwórz porównanie modeli →

FLUX 3 - Real World Models: Towards Multimodal Flow Models as the Backbone of Visual Intelligence.

Uptime

Sprawdź dane heartbeat na żywo, dostępność endpointu i zaobserwowane czasy odpowiedzi przed przejściem do produkcji.

Wersje

Sprawdź dostępne identyfikatory modeli przed ustaleniem integracji produkcyjnej.

doubao-seedance-2-0

doubao-seedance-2-0-fast

doubao-seedance-2-0-mini

Kontynuuj eksplorację