Doubao-Seedance-2-0

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

Seedance 2.0 ondersteunt multimodale invoer, waaronder tekstprompts, tot 9 afbeeldingen, tot 3 korte videoclips en tot 3 audiobestanden, die vrij te combineren zijn voor rijke, controleerbare generatie.

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

Ja — Seedance 2.0 is ontworpen voor coherente verhaallijnen met meerdere shots, met consistente personages, visuele stijl en sfeer over scènes heen, waardoor veelvoorkomende AI-videodriftproblemen worden verminderd.

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

Seedance 2.0 kan video’s van cinematografische kwaliteit genereren (tot 2K-resolutie) met native audio, gesynchroniseerde dialoog en natuurlijke bewegingsynthese, doorgaans in clips van 5–60 seconden.

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

Het model genereert audio en video gezamenlijk en biedt native audiovisuele synchronisatie met lipsynchronisatie op fonemeniveau in 8+ talen, voor natuurlijke spraak en geluidseffecten.

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

Ja — de multimodale sturing, continuïteit over meerdere shots en uitvoer met hoge fideliteit van Seedance 2.0 maken het geschikt voor marketingvideo’s, verhalende shorts, advertenties en andere professionele toepassingen.

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

Gebruikers kunnen referentie-assets uploaden en vervolgens in natuurlijke taal beschrijven hoe elke asset de beweging, camerabeweging of stilistische elementen moet beïnvloeden, wat fijnmazige controle over de gegenereerde content biedt.

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

Ja — het model ondersteunt het verlengen van video’s en gerichte bewerkingen, zoals het toevoegen van scènes, het vervangen van personages of het wijzigen van specifieke segmenten, terwijl onbewerkte delen behouden blijven.

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

Typische uitvoerlengtes variëren van ~5 tot ~60 seconden per video, en het combineren van veel assets of hoge-resolutie-instellingen kan de generatietijd vergroten.

Per Seconde:$0.08

Seedance 2.0 is het multimodale videobasismodel van ByteDance van de volgende generatie, gericht op cinematografische, multi-shot narratieve videogeneratie. In tegenstelling tot single-shot tekst-naar-video-demo's legt Seedance 2.0 de nadruk op referentiegestuurde aansturing (afbeeldingen, korte clips, audio), coherente personage-/stijlconsistentie tussen shots en native audio-/videosynchronisatie — met als doel AI-video bruikbaar te maken voor professionele creatieve en previsualisatie-workflows.

Nieuw

Commercieel gebruik

Overzicht

Functies

Prijzen

API

Versies

Technische specificaties van Doubao Seedance 2.0

Item	Details
Productfamilie	ByteDance Seedance-videogeneratiefamilie
CometAPI-slug	doubao-seedance-2-0
Aanbieder	ByteDance / BytePlus ModelArk
Modeltype	Videogeneratiemodel
Invoermodaliteiten	Tekst, afbeelding, audio, video
Referentiecapaciteit	Tot maximaal 9 afbeeldingen, 3 videoclips en 3 audioclips in één multimodale aanvraag
Uitvoertype	MP4-video
Uitvoerresolutie	480p, 720p, 1080p
Beeldverhoudingen	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Uitvoerduur	4–15 seconden
API-stijl	Asynchrone, taakgebaseerde videogeneratie

Wat is Doubao Seedance 2.0?

Doubao Seedance 2.0 is het vlaggenschip van ByteDance op het gebied van multimodale videogeneratie (uitgebracht in februari 2026). Het gebruikt een verenigde audio-video joint-generatiearchitectuur die precieze regisseurscontrole mogelijk maakt door gelijktijdig meerdere afbeeldingen, videoclips en audiobestanden te refereren. Het blinkt uit in het produceren van cinematografische, bewegingsstabiele video's met native audiosynchronisatie — ideaal voor professionele makers die realistische fysica, consistente personages en complexe scènecompositie nodig hebben.

Belangrijkste functies van Doubao Seedance 2.0 op CometAPI

Geünificeerde multimodale generatie: Accepteert tekst-, afbeelding-, audio- en video-invoer in één workflow, zodat gebruikers een scène kunnen regisseren met rijkere referentiematerialen dan een generator die alleen tekst gebruikt.
Regiestijlcontrole: Het model is gebouwd om prompts te volgen voor performance, belichting, schaduw, camerabeweging, bewegingsritme en geluidskenmerken.
Videobewerking en -uitbreiding: Seedance 2.0 is niet beperkt tot een eerste generatie; het ondersteunt het bewerken van specifieke clips, personages, acties en verhaallijnen, plus uitbreiding vooruit/achteruit.
Sterke audiovisuele sync: ByteDance benadrukt tweekanaals stereo-uitvoer en gesynchroniseerde achtergrondmuziek, omgevingsgeluid en gedrag van de voice-over voor meer meeslepende resultaten.
Hoge stuurbaarheid bij complexe scènes: Het benadrukt een verbeterde afhandeling van complexe interacties, bewegingsscènes en fysieke plausibiliteit vergeleken met Seedance 1.5.
Productiegerichte output: De API ondersteunt configureerbare verhouding, duur en watermerkinstellingen, wat het model praktisch maakt voor herhaalbare contentworkflows.

Benchmarkprestaties

ByteDance stelt dat Seedance 2.0 de interne SeedVideoBench-2.0-evaluatie gebruikt en een leidende positie inneemt binnen text-to-video-, image-to-video- en multimodale taakdimensies. Het model verbetert de generatiekwaliteit, fysieke nauwkeurigheid, realisme en stuurbaarheid ten opzichte van Seedance 1.5, vooral in complexe interactie- en bewegingsscènes.

Seedance 2.0 API- en Seedance 2.0 Fast API-modi op CometAPI

Model	Modelnaam in CometAPI	Het meest geschikt voor	Belangrijkste verschil
Seedance 2.0	doubao-seedance-2-0	Multimodale videogeneratie van de hoogste kwaliteit	Breedste referentiestack en sterkste stuurbaarheid binnen de Seedance 2.0-familie.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Snellere productie wanneer er iets aan kwaliteit kan worden ingeleverd	ByteDance zegt dat het dezelfde modelmogelijkheden behoudt als Seedance 2.0, maar sneller genereert.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Gecombineerde audio-videogeneratie van een eerdere generatie	Seedance 1.5 Pro is gepositioneerd als een native, gezamenlijk audio-videomodel, terwijl Seedance 2.0 de multimodale referentie- en bewerkingsstack uitbreidt.

Sterke punten t.o.v. concurrenten:

vs Kling 3.0: Betere multimodale referentiecontrole en native audio.
vs Sora 2: Superieure referentieprecisie en multi-shot-capaciteit; iets lagere maximale duur.
vs Veo 3.1: Sterker in personageconsistentie en promptnauwkeurigheid voor referentie-intensieve workflows; Veo loopt voorop in pure cinematografische grading en langere clips.

Blinkt uit in mensgerichte en door acteerprestaties gedreven video's.

Probeer de Seedance 2.0 AI-videogenerator op CometAPI

Stap 1: Stap 1: Meld je aan voor een API-sleutel

Begin direct in de CometAPI Playground om Doubao Seedance 2.0 te ervaren zonder installatie of coderen. Log simpelweg in op je CometAPI-account, ga naar de modelpagina voor doubao-seedance-2-0, upload je referentieafbeeldingen, korte videoclips of audiobestanden, voeg een beschrijvende prompt toe en genereer direct previewvideo's. Dit is de snelste manier om te begrijpen hoe Seedance 2.0 omgaat met bewegingsconsistentie, het uiterlijk van personages, camerabewegingen en native audiosynchronisatie.

Stap 2: Krijg API-toegang voor Seedance 2.0 op CometAPI

Maak een nieuwe CometAPI-sleutel aan of gebruik je bestaande sleutel om volledige toegang tot Doubao Seedance 2.0 te krijgen. Navigeer na het inloggen naar de API Token-sectie in je console, genereer een nieuwe sleutel en kopieer deze. Bezoek vervolgens de Seedance 2.0-modeldetailpagina en de API-documentatie op CometAPI om de ondersteunde parameters te bekijken voor integratie in je projecten.

Stap 3: Verstuur je eerste verzoek met de Seedance 2.0 API

Gebruik het CometAPI-endpoint om je eerste videogeneratieverzoek in te dienen met een duidelijke tekstprompt en optionele referentiebestanden (afbeeldingen, video of audio). Het systeem verwerkt de taak asynchroon, retourneert een taak-ID en levert een downloadbare MP4-video zodra deze is voltooid. Je kunt vervolgens je prompts verfijnen, instellingen aanpassen en opschalen voor marketingvideo's, sociale content, geautomatiseerde videopijplijnen of creatieve toepassingen aangedreven door Seedance 2.0.

Deze workflow geeft je snelle experimentatie in de Playground en een soepele overgang naar productiegebruik via de CometAPI.

Belangrijkste redenen om Seedance 2.0 op CometAPI te kiezen

Waarom CometAPI gebruiken voor Seedance 2.0

Directe toegang via API of Playground
Eenvoudige parametercontrole (duur, resolutie, formaat)
Ondersteunt zowel tekst-naar-video- als afbeelding-naar-videoworkflows
Ingebouwde taakafhandeling voor asynchrone videogeneratie

Eengemaakte & ontwikkelaarsvriendelijke API

CometAPI biedt een schoon, gestandaardiseerd endpoint dat naadloos werkt met vertrouwde OpenAI-stijlformaten of dedicated endpoints voor videotaken. Je krijgt rechttoe-rechtaan taakcreatie, polling en MP4-downloads zonder gedoe met de complexe authenticatie of regionale beperkingen van Volcengine.

Kosteneffectieve prijsstelling

CometAPI levert doorgaans meer concurrerende tarieven per seconde dan directe aanbieders, waardoor je grootschalig hoogwaardige video's kunt genereren voor marketing, sociale media of geautomatiseerde pijplijnen zonder je budget te overschrijden.

Snel testen met Playground

Experimenteer direct in de CometAPI Playground. Upload referentieafbeeldingen, -video's en -audiobestanden, tweek prompts en bekijk previews binnen minuten — perfect om te itereren op stijl, beweging en audiosynchronisatie voordat je naar productie gaat.

Kortom, als je de creatieve kracht van Seedance 2.0 wilt — eersteklas referentiecontrole, natuurlijke beweging en native audio — zonder het gedoe van directe toegang via ByteDance, dan is CometAPI momenteel een van de beste platforms om het te gebruiken.

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?

Functies voor Doubao-Seedance-2-0

<think> 用户要求我将英文文本翻译成荷兰语(Nederlands)。我需要注意： 1. 保持格式和特殊字符（如{} 变量占位符） 2. 技术术语保持准确性 3. 保持语气和风格 4. UI文本要简洁明了 5. 只返回翻译文本，不要添加解释 6. 不要添加任何前缀或说明原文是： "Explore the key features of Doubao-Seedance-2-0, designed to enhance performance and usability. Discover how these capabilities can benefit your projects and improve user experience." 这看起来是产品或技术介绍的文本，需要翻译成荷兰语。我需要保持Doubao-Seedance-2-0这个占位符不变。让我翻译： - Explore = Ontdek/Verken - key features = belangrijkste functies/eigenschappen - designed to enhance = ontworpen om te verbeteren - performance = prestaties - usability = bruikbaarheid - Discover = Ontdek - capabilities = mogelijkheden - benefit = ten goede komen/voordeel opleveren - projects = projecten - improve = verbeteren - user experience = gebruikerservaring 翻译： Ontdek de belangrijkste functies van Doubao-Seedance-2-0, ontworpen om prestaties en bruikbaarheid te verbeteren. Ontdek hoe deze mogelijkheden uw projecten ten goede kunnen komen en de gebruikerservaring kunnen verbeteren. 不过"Ontdek"出现了两次，可能需要调整一下： Verken de belangrijkste functies van Doubao-Seedance-2-0, ontworpen om prestaties en bruikbaarheid te verbeteren. Ontdek hoe deze mogelijkheden uw projecten ten goede kunnen komen en de gebruikerservaring kunnen verbeteren. I'll explore how these capabilities can positively impact your projects and optimize the user experience. </think> Verken de belangrijkste functies van Doubao-Seedance-2-0, ontworpen om prestaties en bruikbaarheid te verbeteren. Ontdek hoe deze mogelijkheden uw projecten ten goede kunnen komen en de gebruikerservaring verbeteren.

Prijzen voor Doubao-Seedance-2-0

Ontdek concurrerende prijzen voor Doubao-Seedance-2-0, ontworpen om te passen bij verschillende budgetten en gebruiksbehoeften. Onze flexibele abonnementen zorgen ervoor dat u alleen betaalt voor wat u gebruikt, waardoor het gemakkelijk is om op te schalen naarmate uw vereisten groeien. Ontdek hoe Doubao-Seedance-2-0 uw projecten kan verbeteren terwijl de kosten beheersbaar blijven.

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.

Voorbeeldcode en API voor Doubao-Seedance-2-0

Krijg toegang tot uitgebreide voorbeeldcode en API-bronnen voor Doubao-Seedance-2-0 om uw integratieproces te stroomlijnen. Onze gedetailleerde documentatie biedt stapsgewijze begeleiding en helpt u het volledige potentieel van Doubao-Seedance-2-0 in uw projecten te benutten.

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

Versies van Doubao-Seedance-2-0

De reden waarom Doubao-Seedance-2-0 meerdere snapshots heeft, kan mogelijke factoren omvatten zoals variaties in de uitvoer na updates die oudere snapshots vereisen voor consistentie, het bieden van een overgangsperiode voor ontwikkelaars om zich aan te passen en te migreren, en verschillende snapshots die overeenkomen met wereldwijde of regionale eindpunten om de gebruikerservaring te optimaliseren. Voor gedetailleerde verschillen tussen versies, raadpleeg de officiële documentatie.

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

Meer modellen

Gerelateerde blogs

Apr 17, 2026

De Seedance 2.0 API gebruiken

Seedance 2.0 API is ByteDance's nieuwste multimodale AI-videogeneratiemodel (gelanceerd op 9 april 2026). Het accepteert tekst, afbeeldingen, videoclips en audio in één aanvraag om filmische MP4-video's van 4–15 seconden te produceren, met native audiosynchronisatie, camerabesturing op regisseursniveau en uitzonderlijke bewegingsconsistentie. Gebruik: meld u aan op CometAPI.com, verkrijg een API-sleutel, dien via REST een asynchrone taak in, poll op voltooiing en download de video-URL.

Apr 11, 2026

Wat is HappyHorse-1.0? Hoe vergelijk je Seedance 2.0?

Kom te weten wat HappyHorse-1.0 is, waarom het de top van de Artificial Analysis-videoranglijst bereikte, hoe het zich verhoudt tot Seedance 2.0 en wat de nieuwste ranglijsten betekenen voor AI-videogeneratie.

Mar 24, 2026

Wat is Seedance 2.0? Een uitgebreide analyse

Seedance 2.0 is een multimodaal AI-videogeneratiemodel van de volgende generatie, ontwikkeld door ByteDance, dat op basis van tekst, afbeeldingen, audio en referentievideo's hoogwaardige, filmische video's kan genereren. Het biedt gezamenlijke audio- en videogeneratie, bewegingsstabiliteit en referentiegebaseerde bewerking, en is snel opgeklommen op wereldwijde benchmarks zoals de Artificial Analysis leaderboard, waarmee het zich in 2026 positioneert tussen de toonaangevende AI-videomodellen.