Doubao-Seedance-2-0

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

Seedance 2.0 understøtter multimodale input, herunder tekstprompter, op til 9 billeder, op til 3 korte videoklip og op til 3 lydfiler, som frit kan kombineres for en rig og kontrollerbar generering.

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

Ja — Seedance 2.0 er designet til sammenhængende fortælling i flere indstillinger med konsistente karakterer, visuelt udtryk og atmosfære på tværs af scener, hvilket reducerer almindelige problemer med afdrift i AI-videoer.

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

Seedance 2.0 kan generere filmiske videoer (op til 2K opløsning) med indbygget lyd, synkroniseret dialog og naturlig bevægelsessyntese, typisk i klip på 5–60 sekunder.

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

Modellen genererer lyd og video samlet og tilbyder indbygget audiovisuel synkronisering med lippesynkronisering på fonemniveau på 8+ sprog for naturlig tale og lydeffekter.

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

Ja — Seedance 2.0’s multimodale kontrol, kontinuitet på tværs af flere indstillinger og output i høj kvalitet gør den egnet til marketingvideoer, narrative kortfilm, reklamer og andre professionelle anvendelser.

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

Brugere kan uploade referencemateriale og derefter beskrive i naturligt sprog, hvordan hvert enkelt skal påvirke bevægelse, kamerabevægelse eller stilistiske elementer, hvilket giver finmasket kontrol over det genererede indhold.

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

Ja — modellen understøtter videoudvidelse og målrettet redigering som at tilføje scener, erstatte karakterer eller ændre specifikke segmenter, samtidig med at uredigerede dele bevares.

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

Typiske outputlængder spænder fra ~5 til ~60 sekunder pr. video, og kombination af mange ressourcer eller højopløsningsindstillinger kan øge genereringstiden.

Per Sekund:$0.08

Seedance 2.0 er ByteDance’s næste generations multimodale videogrundmodel med fokus på cinematisk, fortællende videogenerering med flere indstillinger. I modsætning til enkelt‑indstillings tekst‑til‑video‑demoer lægger Seedance 2.0 vægt på referencebaseret styring (billeder, korte klip, lyd), sammenhængende karakter- og stilkonsistens på tværs af indstillinger samt indbygget lyd-/videosynkronisering — med det mål at gøre AI‑video nyttig for professionelle kreative og arbejdsgange til previsualisering.

Kommersiel brug

Oversigt

Funktioner

Priser

API

Versioner

Tekniske specifikationer for Doubao Seedance 2.0

Punkt	Detaljer
Produktfamilie	ByteDance Seedance videogenreringsfamilie
CometAPI-slug	doubao-seedance-2-0
Udbyder	ByteDance / BytePlus ModelArk
Modeltype	Videogenereringsmodel
Inputmodaliteter	Tekst, billede, lyd, video
Referencekapacitet	Op til 9 billeder, 3 videoklip og 3 lydklip i en enkelt multimodal anmodning
Outputtype	MP4-video
Outputopløsning	480p, 720p, 1080p
Sideforhold	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Outputvarighed	4–15 sekunder
API-stil	Asynkron, opgavebaseret videogenerering

Hvad er Doubao Seedance 2.0?

Doubao Seedance 2.0 er ByteDance’s flagskibs multimodale videogenereringsmodel (udgivet februar 2026). Den bruger en samlet arkitektur til fælles generering af lyd og video, som muliggør præcis kontrol på instruktørniveau ved samtidig at referere til flere billeder, videoklip og lydfiler. Den udmærker sig ved at producere cinematiske, bevægelsesstabile videoer med nativ lydsynkronisering — ideel til professionelle skabere, der har brug for realistisk fysik, konsekvente karakterer og kompleks scenekomposition.

Hovedfunktioner i Doubao Seedance 2.0 på CometAPI

Samlet multimodal generering: Accepterer input af tekst, billede, lyd og video i én arbejdsgang, så brugere kan instruere en scene med rigere referencegrundlag end en ren tekstgenerator.
Instruktør-lignende kontrol: Modellen er bygget til at følge prompts for præstation/udtryk, lys, skygge, kamerabevægelse, bevægelsesrytme og lydkarakteristika.
Videoredigering og udvidelse: Seedance 2.0 er ikke begrænset til førstegenerering; den understøtter redigering af specifikke klip, karakterer, handlinger og fortællingsforløb samt fremad-/tilbageudvidelse.
Stærk audiovisuel synkronisering: ByteDance fremhæver to-kanals stereooutput og synkroniseret baggrundsmusik, omgivelseslyd og speak for mere immersive resultater.
Høj styrbarhed i komplekse scener: Den fremhæver forbedret håndtering af komplekse interaktioner, bevægelsesscener og fysisk plausibilitet sammenlignet med Seedance 1.5.
Produktionsorienteret output: API’et understøtter konfigurerbare sideforhold, varighed og vandmærkeindstillinger, hvilket gør modellen praktisk til gentagelige indholds-workflows.

Benchmark-ydelse

ByteDance siger, at Seedance 2.0 bruger den interne SeedVideoBench-2.0 evaluering og placerer sig i førerfeltet på tværs af tekst-til-video, billede-til-video og multimodale opgavedimensioner. Modellen forbedrer genereringskvalitet, fysisk nøjagtighed, realisme og styrbarhed i forhold til Seedance 1.5, især i komplekse interaktions- og bevægelsesscener.

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

Model	Modelnavn i CometAPI	Bedst til	Vigtigste forskel
Seedance 2.0	doubao-seedance-2-0	Multimodal videogenerering i højeste kvalitet	Bredeste referencestak og stærkest styrbarhed i Seedance 2.0-familien.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Hurtigere produktion, når der kan ofres lidt kvalitet	ByteDance siger, at den bevarer de samme modelkapabiliteter som Seedance 2.0, men genererer hurtigere.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Lyd- og videogenerering i tidligere generation	Seedance 1.5 Pro er positioneret som en nativ fælles lyd- og videomodel, mens Seedance 2.0 udvider den multimodale reference- og redigeringsstak.

Styrker vs. konkurrenter:

vs Kling 3.0: Bedre multimodal referencekontrol og nativ lyd.
vs Sora 2: Overlegen referencepræcision og multi-shot-kapacitet; en smule lavere maks. varighed.
vs Veo 3.1: Stærkere i karakterkonsistens og prompt-efterlevelse til reference-tunge workflows; Veo fører i rå filmisk farvegrading og længere klip.

Udmarker sig i menneskecentrerede og performance-drevne videoer.

Prøv Seedance 2.0 AI-videogeneratoren på CometAPI

Trin 1: Trin 1: Tilmeld dig for at få en API-nøgle

Start direkte i CometAPI Playground for at afprøve Doubao Seedance 2.0 uden opsætning eller kodning. Log bare ind på din CometAPI-konto, gå til modelsiden for doubao-seedance-2-0, upload dine referencebilleder, korte videoklip eller lydfiler, tilføj en beskrivende prompt, og generér forhåndsvisningsvideoer med det samme. Dette er den hurtigste måde at forstå, hvordan Seedance 2.0 håndterer bevægelseskonsistens, karakterudseende, kamerabevægelser og nativ lydsynkronisering.

Trin 2: Få API-adgang til Seedance 2.0 på CometAPI

Opret eller brug din eksisterende CometAPI-nøgle for at få fuld adgang til Doubao Seedance 2.0. Når du er logget ind, skal du navigere til sektionen API Token i din konsol, generere en ny nøgle og kopiere den. Besøg derefter Seedance 2.0 modeldetaljesiden og API-dokumentation på CometAPI for at gennemgå de understøttede parametre til integration i dine projekter.

Trin 3: Send din første anmodning med Seedance 2.0-API’et

Brug CometAPI-endpointet til at indsende din første videogenereringsanmodning med en klar tekstprompt og valgfrie referencefiler (billeder, video eller lyd). Systemet behandler opgaven asynkront, returnerer et opgave-ID og giver en downloadbar MP4-video, når den er færdig. Du kan derefter forfine dine prompts, justere indstillinger og skalere op til marketingvideoer, indhold til sociale medier, automatiserede videopipelines eller kreative applikationer drevet af Seedance 2.0.

Denne arbejdsgang giver dig hurtige eksperimenter i Playground og en smidig overgang til produktionsbrug via CometAPI.

De bedste grunde til at vælge Seedance 2.0 på CometAPI

Hvorfor bruge CometAPI til Seedance 2.0

Direkte adgang via API eller Playground
Let parameterkontrol (varighed, opløsning, format)
Understøtter både tekst-til-video og billede-til-video arbejdsgange
Indbygget jobhåndtering til asynkron videogenerering

Samlet og udviklervenlig API

CometAPI tilbyder et rent, standardiseret endpoint, der fungerer problemfrit med velkendte formater i OpenAI-stil eller dedikerede endpoints til videoopgaver. Du får enkel oprettelse af opgaver, polling og MP4-downloads uden at skulle håndtere Volcengine’s komplekse godkendelse eller regionale begrænsninger.

Omkostningseffektiv prissætning

CometAPI leverer typisk mere konkurrencedygtige priser pr. sekund sammenlignet med direkte udbydere, så du kan generere videoer i høj kvalitet i stor skala til marketing, sociale medier eller automatiserede pipelines uden at sprænge budgettet.

Hurtig test med Playground

Eksperimenter med det samme i CometAPI Playground. Upload referencebilleder, videoer og lydfiler, justér prompts, og forhåndsvis resultater på få minutter — perfekt til at iterere på stil, bevægelse og lydsynkronisering før produktion.

Kort sagt, hvis du vil have den kreative kraft fra Seedance 2.0 — referencekontrol i topklasse, naturlig bevægelse og nativ lyd — uden besværet ved direkte adgang til ByteDance, er CometAPI i øjeblikket en af de bedste platforme at bruge.

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

Udforsk konkurrencedygtige priser for Doubao-Seedance-2-0, designet til at passe til forskellige budgetter og brugsbehov. Vores fleksible planer sikrer, at du kun betaler for det, du bruger, hvilket gør det nemt at skalere, efterhånden som dine krav vokser. Opdag hvordan Doubao-Seedance-2-0 kan forbedre dine projekter, mens omkostningerne 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 til Doubao-Seedance-2-0

Få adgang til omfattende eksempelkode og API-ressourcer for Doubao-Seedance-2-0 for at strømline din integrationsproces. Vores detaljerede dokumentation giver trin-for-trin vejledning, der hjælper dig med at udnytte det fulde potentiale af Doubao-Seedance-2-0 i dine projekter.

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

Versioner af Doubao-Seedance-2-0

Årsagen til, at Doubao-Seedance-2-0 har flere øjebliksbilleder kan omfatte potentielle faktorer såsom variationer i output efter opdateringer, der kræver ældre øjebliksbilleder for konsistens, at give udviklere en overgangsperiode til tilpasning og migration, og at forskellige øjebliksbilleder svarer til globale eller regionale slutpunkter for at optimere brugeroplevelsen. For detaljerede forskelle mellem versioner, henvises der til den officielle dokumentation.

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

Flere modeller

Relaterede blogs

Apr 17, 2026

Sådan bruger du Seedance 2.0 API

Seedance 2.0 API er ByteDances nyeste multimodale AI-videogenereringsmodel (lanceret 9. april 2026). Den accepterer tekst, billeder, videoklip og lyd i én enkelt anmodning for at producere filmiske MP4-videoer på 4–15 sekunder med indbygget lydsynkronisering, kamerakontrol på instruktørniveau og exceptionel bevægelseskonsistens. For at bruge den: tilmeld dig på CometAPI.com, få en API-nøgle, indsend en asynkron opgave via REST, poll for færdiggørelse, og download video-URL'en.

Apr 11, 2026

Hvad er HappyHorse-1.0? Hvordan sammenligner man Seedance 2.0?

Find ud af, hvad HappyHorse-1.0 er, hvorfor det kom helt til tops på Artificial Analysis' videorangliste, hvordan det står sig i forhold til Seedance 2.0, og hvad de seneste placeringer betyder for AI-videogenerering.

Mar 24, 2026

Hvad er Seedance 2.0? En omfattende analyse

Seedance 2.0 er en næste generations multimodal AI-videogenereringsmodel udviklet af ByteDance, som kan generere filmiske videoer i høj kvalitet ud fra tekst, billeder, lyd og referencevideoer. Den har fælles generering af lyd og video, bevægelsesstabilitet og referencebaseret redigering og er hurtigt steget på globale benchmarks som Artificial Analysis-ranglisten, hvilket placerer den blandt de bedste AI-videomodeller i 2026.