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

Per sekund:$0.056

Utgitt:Apr 19, 2026

Seedance 2.0 er ByteDances neste generasjons multimodale grunnmodell for video, med fokus på filmisk, fortellende videogenerering med flere klipp. I motsetning til tekst-til-video-demoer med kun ett klipp, vektlegger Seedance 2.0 referansebasert kontroll (bilder, korte klipp, lyd), konsekvent karakter og stil på tvers av klipp, og innebygd lyd-/videosynkronisering — med mål om å gjøre AI-video nyttig for profesjonelle kreative- og previsualiseringsarbeidsflyter.

Populær

Kommersiell bruk

Playground for Seedance 2-0

Utforsk Seedance 2-0's Playground — et interaktivt miljø for å teste modeller og kjøre spørringer i sanntid. Prøv prompts, juster parametere og iterer umiddelbart for å akselerere utvikling og validere brukstilfeller.

Tekniske spesifikasjoner for Doubao Seedance 2.0

Element	Detaljer
Produktfamilie	ByteDance Seedance-videogenereringsfamilien
CometAPI-slug	doubao-seedance-2-0
Leverandør	ByteDance / BytePlus ModelArk
Modelltype	Videogenereringsmodell
Inndatatyper	Tekst, bilde
Utdatatype	MP4-video
Utdataoppløsning	480p, 720p, 1080p
Sideforhold	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Utdatavarighet	4–15 sekunder
API-stil	Asynkron oppgavebasert videogenerering

Hva er Doubao Seedance 2.0?

Doubao Seedance 2.0 er ByteDances flaggskip innen multimodal videogenerering (lansert februar 2026). Den bruker en enhetlig lyd–video felles generasjonsarkitektur som muliggjør presis kontroll på regissørnivå ved samtidig referanse til flere bilder, videoklipp og lydfiler. Den utmerker seg i å produsere filmatiske, bevegelsesstabile videoer med innebygd lydsynkronisering — ideell for profesjonelle skapere som trenger realistisk fysikk, konsistente karakterer og kompleks scenekomposisjon.

Hovedfunksjoner i Doubao Seedance 2.0 på CometAPI

Enhetlig multimodal generering: Godtar tekst-, bilde-, lyd- og videoinndata i én arbeidsflyt, slik at brukere kan regissere en scene med rikere referansemateriale enn en ren tekstgenerator.
Kontroll i regissørstil: Modellen er bygget for å følge instrukser for prestasjon/uttrykk, lyssetting, skygge, kamerabevegelse, bevegelsesrytme og lydkarakteristikk.
Videoredigering og utvidelse: Seedance 2.0 er ikke begrenset til førstegenerering; den støtter redigering av bestemte klipp, karakterer, handlinger og historier, samt forlengelse fremover/bakover.
Sterk audiovisuell synkronisering: ByteDance fremhever tokanals stereoutgang og synkronisert bakgrunnsmusikk, omgivelseslyd og voiceover-atferd for mer oppslukende resultater.
Høy kontrollerbarhet for komplekse scener: Har forbedret håndtering av komplekse interaksjoner, bevegelsesscener og fysisk plausibilitet sammenlignet med Seedance 1.5.
Produksjonsorientert utdata: API-et støtter konfigurerbare sideforhold, varighet og vannmerkeinnstillinger, noe som gjør modellen praktisk for repeterbare innholdsarbeidsflyter.

Benchmark-ytelse

ByteDance sier at Seedance 2.0 bruker den interne evalueringen SeedVideoBench-2.0 og plasserer seg i teten på tvers av tekst-til-video, bilde-til-video og multimodale oppgavedimensjoner. Modellen forbedrer generasjonskvalitet, fysisk nøyaktighet, realisme og kontrollerbarhet sammenlignet med Seedance 1.5, spesielt i komplekse interaksjons- og bevegelsesscener.

Seedance 2.0 API og Seedance 2.0 Fast API-moduser på CometAPI

Modell	Modellnavn i CometAPI	Best for	Hovedforskjell
Seedance 2.0	doubao-seedance-2-0	Multimodal videogenerering av høyeste kvalitet	Bredeste referansestakk og sterkeste kontrollerbarhet i Seedance 2.0-familien.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Raskere produksjon når man kan ofre litt kvalitet	ByteDance sier at den beholder de samme modellfunksjonene som Seedance 2.0, men genererer raskere.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Tidligere generasjons lyd–video-generering	Seedance 1.5 Pro er posisjonert som en native felles lyd–video-modell, mens Seedance 2.0 utvider den multimodale referanse- og redigeringsstakken.

Styrker vs konkurrenter:

vs Kling 3.0: Bedre multimodal referansekontroll og innebygd lyd.
vs Sora 2: Overlegen referansepresisjon og mulighet for flere opptak; noe lavere maksvarighet.
vs Veo 3.1: Sterkere på karakterkonsistens og etterlevelse av prompt for referansetunge arbeidsflyter; Veo leder på rå filmatisk grading og lengre klipp.

Utmerker seg i menneskesentrerte og prestasjonsdrevne videoer.

Prøv Seedance 2.0 AI Video Generator på CometAPI

Trinn 1: Trinn 1: Registrer deg for API-nøkkel

Start direkte i CometAPI Playground for å prøve Doubao Seedance 2.0 uten oppsett eller koding. Bare logg inn på CometAPI-kontoen din, gå til modellsiden for doubao-seedance-2-0, last opp referansebilder, korte videoklipp eller lydfiler, legg til en beskrivende prompt, og generer forhåndsvisningsvideoer umiddelbart. Dette er den raskeste måten å forstå hvordan Seedance 2.0 håndterer bevegelseskonsistens, karakterutseende, kamerabevegelser og innebygd lydsynkronisering.

Trinn 2: Få API-tilgang til Seedance 2.0 på CometAPI

Opprett eller bruk din eksisterende CometAPI-nøkkel for å få full tilgang til Doubao Seedance 2.0. Etter innlogging går du til API Token-seksjonen i konsollen din, genererer en ny nøkkel og kopierer den. Gå deretter til modelsiden for Seedance 2.0 og API-dokumentasjonen på CometAPI for å gjennomgå de støttede parameterne for integrasjon i prosjektene dine.

Trinn 3: Send din første forespørsel med Seedance 2.0 API

Bruk CometAPI-endepunktet for å sende din første forespørsel om videogenerering med en tydelig tekstprompt og valgfrie referansefiler (bilder, video eller lyd). Systemet vil behandle oppgaven asynkront, returnere en oppgave-ID og gi en nedlastbar MP4-video når den er fullført. Du kan deretter finjustere promptene dine, justere innstillinger og skalere opp for markedsføringsvideoer, innhold i sosiale medier, automatiserte videopipelines eller kreative applikasjoner drevet av Seedance 2.0.

Denne arbeidsflyten gir rask eksperimentering i playgrounden og en smidig overgang til produksjonsbruk via CometAPI.

Toppgrunner til å velge Seedance 2.0 på CometAPI

Hvorfor bruke CometAPI for Seedance 2.0

Direkte tilgang via API eller Playground
Enkel parameterkontroll (varighet, oppløsning, format)
Støtter både tekst-til-video og bilde-til-video arbeidsflyter
Innebygd jobbhåndtering for asynkron videogenerering

Enhetlig og utviklervennlig API

CometAPI tilbyr et ryddig, standardisert endepunkt som fungerer sømløst med kjente OpenAI-lignende formater eller dedikerte videotask-endepunkter. Du får enkel opprettelse av oppgaver, polling og MP4-nedlastinger uten å håndtere Volcengines komplekse autentisering eller regionale begrensninger.

Kostnadseffektiv prising

CometAPI leverer typisk mer konkurransedyktige satser per sekund sammenlignet med direkte leverandører, slik at du kan generere video i høy kvalitet i stor skala for markedsføring, sosiale medier eller automatiserte pipelines uten å sprenge budsjettet.

Rask testing med Playground

Eksperimenter umiddelbart i CometAPI Playground. Last opp referansebilder, videoer og lydfiler, juster promptene, og forhåndsvis resultater på minutter — perfekt for iterasjon på stil, bevegelse og lydsynk før produksjon.

Kort sagt, hvis du vil ha den kreative kraften i Seedance 2.0 — referansekontroll i toppklasse, naturlige bevegelser og innebygd lyd — uten bryet med direkte ByteDance-tilgang, er CometAPI for øyeblikket en av de beste plattformene å bruke den.

FAQ

Priser for Seedance 2-0

Utforsk konkurransedyktige priser for Seedance 2-0, designet for å passe ulike budsjetter og bruksbehov. Våre fleksible planer sikrer at du bare betaler for det du bruker, noe som gjør det enkelt å skalere etter hvert som kravene dine vokser. Oppdag hvordan Seedance 2-0 kan forbedre prosjektene dine samtidig som kostnadene holdes håndterbare.

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.

Eksempelkode og API for Seedance 2-0

Få tilgang til omfattende eksempelkode og API-ressurser for Seedance 2-0 for å effektivisere integreringsprosessen din. Vår detaljerte dokumentasjon gir trinn-for-trinn-veiledning som hjelper deg med å utnytte det fulle potensialet til Seedance 2-0 i prosjektene dine.

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

Versjoner av Seedance 2-0

Grunnen til at Seedance 2-0 har flere øyeblikksbilder kan inkludere potensielle faktorer som variasjoner i utdata etter oppdateringer som krever eldre øyeblikksbilder for konsistens, å gi utviklere en overgangsperiode for tilpasning og migrering, og ulike øyeblikksbilder som tilsvarer globale eller regionale endepunkter for å optimalisere brukeropplevelsen. For detaljerte forskjeller mellom versjoner, vennligst se den offisielle dokumentasjonen.

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