Doubao-Seedance-2-0

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

Seedance 2.0 støtter multimodale inndata, inkludert tekstprompter, opptil 9 bilder, opptil 3 korte videoklipp og opptil 3 lydfiler, som kan kombineres fritt for rik og kontrollerbar generering.

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

Ja — Seedance 2.0 er designet for sammenhengende historiefortelling over flere opptak, med konsistente karakterer, visuell stil og atmosfære på tvers av scener, noe som reduserer vanlige problemer med avdrift i KI-video.

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

Seedance 2.0 kan generere filmatiske videoer (opptil 2K-oppløsning) med innebygd lyd, synkronisert dialog og naturlig bevegelsessyntese, typisk i klipp på 5–60 sekunder.

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

Modellen genererer lyd og video samtidig, og tilbyr innebygd audiovisuell synkronisering med leppesynk på fonemnivå på 8+ språk for naturlig tale og lydeffekter.

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

Ja — Seedance 2.0s multimodale kontroll, kontinuitet over flere opptak og utdata med høy trofasthet gjør den egnet for markedsføringsvideoer, narrative kortfilmer, annonser og andre profesjonelle bruksområder.

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

Brukere kan laste opp referansemateriale og deretter beskrive på naturlig språk hvordan hver av dem skal påvirke bevegelse, kamerabevegelse eller stilistiske elementer, noe som gir finmasket kontroll over det genererte innholdet.

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

Ja — modellen støtter forlengelse av video og målrettet redigering som å legge til scener, bytte ut karakterer eller endre bestemte segmenter, samtidig som uredigerte deler bevares.

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

Typiske videovarigheter varierer fra ~5 til ~60 sekunder per video, og å kombinere mange ressurser eller høyoppløsningsinnstillinger kan øke genereringstiden.

Per sekund:$0.08

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.

Kommersiell bruk

Oversikt

Funksjoner

Priser

API

Versjoner

Tekniske spesifikasjoner for Doubao Seedance 2.0

Element	Detaljer
Produktfamilie	ByteDance Seedance videogenreringsfamilie
CometAPI-slug	doubao-seedance-2-0
Tilbyder	ByteDance / BytePlus ModelArk
Modelltype	Videogenereringsmodell
Inndatamodaliteter	Tekst, bilde, lyd, video
Referansekapasitet	Opptil 9 bilder, 3 videoklipp og 3 lydklipp i én enkelt multimodal forespørsel
Utdatatype	MP4-video
Utdataoppløsning	480p, 720p, 1080p
Sideforhold	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Varighet (utdata)	4–15 sekunder
API-stil	Asynkron, oppgavebasert videogenerering

Hva er Doubao Seedance 2.0?

Doubao Seedance 2.0 er ByteDance sin flaggskip multimodale videogenereringsmodell (lansert i februar 2026). Den bruker en enhetlig arkitektur for felles generering av lyd og video som muliggjør presis kontroll på regissørnivå ved å referere til flere bilder, videoklipp og lydfiler samtidig. Den utmerker seg i å produsere filmatiske, bevegelsesstabile videoer med nativ lydsynkronisering — ideelt for profesjonelle skapere som trenger realistisk fysikk, konsistente karakterer og kompleks scenekomposisjon.

Hovedfunksjoner i Doubao Seedance 2.0 på CometAPI

Enhetlig multimodal generering: Aksepterer tekst-, bilde-, lyd- og videoinndata i én arbeidsflyt, slik at brukere kan regissere en scene med rikere referansemateriale enn en ren tekstgenerator.
Regissørkontroll: Modellen er bygget for å følge prompt for prestasjon, lyssetting, skygge, kamerabevegelse, bevegelsesrytme og lydkarakteristikker.
Videoredigering og -forlengelse: Seedance 2.0 er ikke begrenset til førstegenerering; den støtter redigering av spesifikke klipp, karakterer, handlinger og historielinjer, samt forlengelse fremover/bakover.
Sterk audiovisuell synk: ByteDance fremhever stereoutgang i to kanaler og synkronisert bakgrunnsmusikk, omgivelseslyd og voiceover-oppførsel for mer immersive resultater.
Høy styrbarhet for komplekse scener: Bedret håndtering av komplekse interaksjoner, bevegelsesscener og fysisk plausibilitet sammenlignet med Seedance 1.5.
Produksjonsorientert utdata: API-et støtter konfigurerbart sideforhold, varighet og vannmerkeinnstillinger, noe som gjør modellen praktisk for repeterbare innholdsarbeidsflyter.

Benchmark-ytelse

ByteDance oppgir at Seedance 2.0 bruker den interne SeedVideoBench-2.0-evalueringen og plasserer seg i tetsjiktet på tvers av dimensjoner for tekst-til-video, bilde-til-video og multimodale oppgaver. Modellen forbedrer generasjonskvalitet, fysisk nøyaktighet, realisme og styrbarhet versus 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 videoproduksjon med høyeste kvalitet	Bredest referansestakk og sterkest styrbarhet i Seedance 2.0-familien.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Raskere produksjon når litt kvalitet kan ofres	ByteDance sier at den beholder de samme modellkapabilitetene som Seedance 2.0, men genererer raskere.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Lyd–video-generering fra en tidligere generasjon	Seedance 1.5 Pro er posisjonert som en nativ 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 nativ lyd.
vs Sora 2: Overlegen referansepresisjon og flerskuddskapasitet; noe lavere maks varighet.
vs Veo 3.1: Sterkere på karakterkonsistens og etterlevelse av prompt for referansetunge arbeidsflyter; Veo leder i rå filmatisk fargegradering og lengre klipp.

Utmerker seg i menneskesentrerte og opptredelsesdrevne 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 å oppleve Doubao Seedance 2.0 uten oppsett eller koding. Logg bare 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 nativ 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, naviger til API Token-seksjonen i konsollen, generer en ny nøkkel og kopier den. Besøk deretter modellsiden for Seedance 2.0 og API-dokumentasjon på CometAPI for å se gjennom 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 videogenreringsforespørsel med en klar 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. Deretter kan du forbedre promptene dine, justere innstillinger og skalere opp for markedsføringsvideoer, sosiale medier-innhold, automatiserte videopipeliner eller kreative applikasjoner drevet av Seedance 2.0.

Denne arbeidsflyten gir deg 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 videouppgave-endepunkter. Du får enkel opprettelse av oppgaver, polling og MP4-nedlastinger uten å måtte håndtere Volcengine sin komplekse autentisering eller regionale begrensninger.

Kostnadseffektiv prising

CometAPI leverer typisk mer konkurransedyktige priser per sekund sammenlignet med direkte tilbydere, slik at du kan generere videoer i høy kvalitet i stor skala for markedsføring, sosiale medier eller automatiserte pipeliner uten å sprenge budsjettet.

Rask testing med Playground

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

Kort fortalt, hvis du vil ha den kreative kraften til Seedance 2.0 — best-i-klassen referansekontroll, naturlig bevegelse og nativ lyd — uten bryet med direkte ByteDance-tilgang, er CometAPI for øyeblikket en av de beste plattformene å bruke.

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?

Priser for Doubao-Seedance-2-0

Utforsk konkurransedyktige priser for Doubao-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 Doubao-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
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.

Eksempelkode og API for Doubao-Seedance-2-0

Få tilgang til omfattende eksempelkode og API-ressurser for Doubao-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 Doubao-Seedance-2-0 i prosjektene dine.

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

Versjoner av Doubao-Seedance-2-0

Grunnen til at Doubao-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

Flere modeller

Relaterte blogger

Apr 17, 2026

Hvordan bruke Seedance 2.0-API-et

Seedance 2.0 API er ByteDances nyeste multimodale KI-videogenereringsmodell (lansert 9. april 2026). Den tar imot tekst, bilder, videoklipp og lyd i én enkelt forespørsel for å produsere filmatiske MP4-videoer på 4–15 sekunder, med innebygd lydsynkronisering, kamerakontroll på regissørnivå og eksepsjonell konsistens i bevegelser. For å bruke den: registrer deg på CometAPI.com, skaff en API-nøkkel, send inn en asynkron oppgave via REST, poll for ferdigstillelse og last ned video-URL-en.

Apr 11, 2026

Hva er HappyHorse-1.0? Hvordan sammenligne Seedance 2.0?

Finn ut hva HappyHorse-1.0 er, hvorfor det gikk til topps på Artificial Analysis' videotoppliste, hvordan det står seg mot Seedance 2.0, og hva de siste rangeringene betyr for KI-videogenerering.

Mar 24, 2026

Hva er Seedance 2.0? En omfattende analyse

Seedance 2.0 er en neste generasjons multimodal AI-videogenereringsmodell utviklet av ByteDance som kan generere kinolignende videoer av høy kvalitet fra tekst, bilder, lyd og referansevideoer. Den har felles generering av lyd og video, stabil bevegelse og referansebasert redigering, og har raskt klatret på globale benchmarker som Artificial Analysis-ledertavlen, noe som plasserer den blant de beste AI-videomodellene i 2026.