Doubao-Seedance-2-0

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

Seedance 2.0 prend en charge des entrées multimodales, notamment des invites textuelles, jusqu’à 9 images, jusqu’à 3 courts clips vidéo et jusqu’à 3 fichiers audio, pouvant être librement combinés pour une génération riche et contrôlable.

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

Oui — Seedance 2.0 est conçu pour une narration multi-plans cohérente, avec des personnages, un style visuel et une atmosphère constants d’une scène à l’autre, ce qui réduit les problèmes courants de dérive des vidéos IA.

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

Seedance 2.0 peut générer des vidéos de qualité cinématographique (jusqu’à une résolution 2K) avec audio natif, dialogues synchronisés et synthèse de mouvements naturelle, généralement sous forme de clips de 5 à 60 secondes.

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

Le modèle génère l’audio et la vidéo conjointement, offrant une synchronisation audio-visuelle native avec une synchronisation labiale au niveau du phonème dans plus de 8 langues, pour une parole et des effets sonores naturels.

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

Oui — le contrôle multimodal, la continuité multi-plans et la haute fidélité des rendus de Seedance 2.0 en font une solution adaptée aux vidéos marketing, aux courts métrages narratifs, aux publicités et à d’autres applications professionnelles.

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

Les utilisateurs peuvent téléverser des ressources de référence, puis décrire en langage naturel comment chacune doit influencer le mouvement, les déplacements de caméra ou les éléments stylistiques, offrant ainsi un contrôle granulaire du contenu généré.

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

Oui — le modèle prend en charge l’extension de vidéos et le montage ciblé, comme l’ajout de scènes, le remplacement de personnages ou la modification de segments spécifiques, tout en préservant les parties non modifiées.

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

La durée des sorties est généralement comprise entre ~5 et ~60 secondes par vidéo, et la combinaison de nombreux éléments ou de réglages haute résolution peut augmenter le temps de génération.

Par Seconde:$0.08

Seedance 2.0 est le modèle de fondation vidéo multimodal de nouvelle génération de ByteDance, axé sur la génération de vidéos narratives cinématographiques à plusieurs plans. Contrairement aux démonstrations texte-vers-vidéo à plan unique, Seedance 2.0 met l’accent sur un contrôle basé sur des références (images, clips courts, audio), la cohérence des personnages et des styles d’un plan à l’autre, ainsi qu’une synchronisation audio/vidéo native — visant à rendre la vidéo générée par IA utile aux workflows professionnels de création et de prévisualisation.

Nouveau

Usage commercial

Aperçu

Fonctionnalités

Tarification

API

Versions

Spécifications techniques de Doubao Seedance 2.0

Élément	Détails
Famille de produits	Famille de génération vidéo Seedance de ByteDance
Slug CometAPI	doubao-seedance-2-0
Fournisseur	ByteDance / BytePlus ModelArk
Type de modèle	Modèle de génération vidéo
Modalités d'entrée	Texte, image, audio, vidéo
Capacité de référence	Jusqu'à 9 images, 3 clips vidéo et 3 clips audio dans une seule requête multimodale
Type de sortie	Vidéo MP4
Résolution de sortie	480p, 720p, 1080p
Rapports d'aspect	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Durée de sortie	4–15 secondes
Style d'API	Génération vidéo asynchrone basée sur des tâches

Qu'est-ce que Doubao Seedance 2.0 ?

Doubao Seedance 2.0 est le modèle phare multimodal de génération vidéo de ByteDance (sorti en février 2026). Il utilise une architecture unifiée de génération audio-vidéo conjointe qui permet un contrôle précis au niveau réalisateur en référencant simultanément plusieurs images, clips vidéo et fichiers audio. Il excelle à produire des vidéos cinématographiques stables en mouvement avec une synchronisation audio native — idéal pour les créateurs professionnels ayant besoin de physique réaliste, de personnages cohérents et de compositions de scènes complexes.

Principales fonctionnalités de Doubao Seedance 2.0 sur CometAPI

Génération multimodale unifiée : Accepte des entrées texte, image, audio et vidéo dans un seul flux de travail, afin que les utilisateurs puissent diriger une scène avec un matériau de référence plus riche qu'avec un générateur uniquement textuel.
Contrôle de style réalisateur : Le modèle est conçu pour suivre les instructions concernant l'interprétation, l'éclairage, les ombres, les mouvements de caméra, le rythme des mouvements et les caractéristiques sonores.
Montage et extension vidéo : Seedance 2.0 ne se limite pas à une première génération ; il prend en charge le montage de clips, de personnages, d'actions et d'histoires spécifiques, ainsi que l'extension vers l'avant et l'arrière.
Synchronisation audiovisuelle robuste : ByteDance met en avant une sortie stéréo à deux canaux et une synchronisation de la musique de fond, des sons d'ambiance et du comportement de la voix off pour des résultats plus immersifs.
Haute contrôlabilité pour les scènes complexes : Il met en avant une meilleure gestion des interactions complexes, des scènes en mouvement et de la plausibilité physique par rapport à Seedance 1.5.
Sortie orientée production : L'API prend en charge des paramètres configurables de ratio, de durée et de filigrane, ce qui rend le modèle pratique pour des flux de contenus reproductibles.

Performances de référence

ByteDance indique que Seedance 2.0 utilise l'évaluation interne SeedVideoBench-2.0 et se place en tête sur les dimensions de tâches texte-vers-vidéo, image-vers-vidéo et multimodales. Le modèle améliore la qualité de génération, l'exactitude physique, le réalisme et la contrôlabilité par rapport à Seedance 1.5, en particulier dans les scènes d'interaction et de mouvement complexes.

Modes Seedance 2.0 API et Seedance 2.0 Fast API sur CometAPI

Modèle	Nom du modèle dans CometAPI	Idéal pour	Différence principale
Seedance 2.0	doubao-seedance-2-0	Création vidéo multimodale de la plus haute qualité	Pile de références la plus large et contrôlabilité la plus poussée de la famille Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Production plus rapide lorsqu'on peut sacrifier un peu de qualité	ByteDance indique qu'il conserve les mêmes capacités que Seedance 2.0, mais génère plus vite.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Création audio-vidéo de génération précédente	Seedance 1.5 Pro se positionne comme un modèle natif de génération conjointe audio-vidéo, tandis que Seedance 2.0 étend la pile de références et de montage multimodale.

Points forts vs concurrents :

vs Kling 3.0 : Meilleur contrôle des références multimodales et audio natif.
vs Sora 2 : Précision des références et capacité multi-plans supérieures ; durée maximale légèrement inférieure.
vs Veo 3.1 : Plus fort en cohérence des personnages et respect des instructions pour les flux de travail riches en références ; Veo domine en étalonnage cinématographique brut et en clips plus longs.

Excelle dans les vidéos centrées sur l'humain et orientées performance.

Essayez le générateur vidéo IA Seedance 2.0 sur CometAPI

Étape 1 : Étape 1 : Inscrivez-vous pour obtenir une clé API

Commencez directement dans le CometAPI Playground pour découvrir Doubao Seedance 2.0 sans configuration ni code. Connectez-vous simplement à votre compte CometAPI, rendez-vous sur la page du modèle doubao-seedance-2-0, téléchargez vos images de référence, courts clips vidéo ou fichiers audio, ajoutez une instruction descriptive et générez instantanément des vidéos d'aperçu. C'est la façon la plus rapide de comprendre comment Seedance 2.0 gère la cohérence des mouvements, l'apparence des personnages, les mouvements de caméra et la synchronisation audio native.

Étape 2 : Obtenez l'accès API pour Seedance 2.0 sur CometAPI

Créez ou utilisez votre clé CometAPI existante pour activer l'accès complet à Doubao Seedance 2.0. Après vous être connecté, accédez à la section API Token de votre console, générez une nouvelle clé et copiez-la. Puis visitez la page de détail du modèle Seedance 2.0 et la documentation API sur CometAPI pour examiner les paramètres pris en charge en vue de l'intégration dans vos projets.

Étape 3 : Envoyez votre première requête avec l'API Seedance 2.0

Utilisez l'endpoint CometAPI pour soumettre votre première requête de génération vidéo avec une instruction textuelle claire et des fichiers de référence optionnels (images, vidéo ou audio). Le système traitera la tâche de manière asynchrone, renverra un ID de tâche et fournira une vidéo MP4 téléchargeable une fois terminé. Vous pourrez ensuite affiner vos instructions, ajuster les paramètres et passer à l'échelle pour des vidéos marketing, du contenu social, des pipelines vidéo automatisés ou des applications créatives alimentées par Seedance 2.0.

Ce flux de travail offre une expérimentation rapide dans le Playground et une transition fluide vers un usage en production via CometAPI.

Principales raisons de choisir Seedance 2.0 sur CometAPI

Pourquoi utiliser CometAPI pour Seedance 2.0

Accès direct via l'API ou le Playground
Contrôle simple des paramètres (durée, résolution, format)
Prend en charge les flux de travail texte-vers-vidéo et image-vers-vidéo
Gestion intégrée des tâches pour la génération vidéo asynchrone

API unifiée et adaptée aux développeurs

CometAPI propose un endpoint propre et standardisé qui fonctionne de manière transparente avec des formats de style OpenAI familiers ou des endpoints dédiés aux tâches vidéo. Vous bénéficiez d'une création de tâches, d'une interrogation et de téléchargements MP4 simples, sans avoir à gérer l'authentification complexe ou les limitations régionales de Volcengine.

Tarification économique

CometAPI propose généralement des tarifs par seconde plus compétitifs que les fournisseurs directs, vous permettant de générer des vidéos de haute qualité à grande échelle pour le marketing, les réseaux sociaux ou des pipelines automatisés sans exploser votre budget.

Tests rapides avec le Playground

Expérimentez immédiatement dans le CometAPI Playground. Téléchargez des images, des vidéos et des fichiers audio de référence, ajustez les instructions et prévisualisez les résultats en quelques minutes — parfait pour itérer sur le style, le mouvement et la synchronisation audio avant de passer en production.

En bref, si vous souhaitez la puissance créative de Seedance 2.0 — contrôle de référence de premier ordre, mouvement naturel et audio natif — sans les tracas de l'accès direct à ByteDance, CometAPI est actuellement l'une des meilleures plateformes pour l'utiliser.

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?

Tarification pour Doubao-Seedance-2-0

Découvrez des tarifs compétitifs pour Doubao-Seedance-2-0, conçus pour s'adapter à différents budgets et besoins d'utilisation. Nos formules flexibles garantissent que vous ne payez que ce que vous utilisez, ce qui facilite l'adaptation à mesure que vos besoins évoluent. Découvrez comment Doubao-Seedance-2-0 peut améliorer vos projets tout en maîtrisant les coûts.

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.

Exemple de code et API pour Doubao-Seedance-2-0

Accédez à des exemples de code complets et aux ressources API pour Doubao-Seedance-2-0 afin de simplifier votre processus d'intégration. Notre documentation détaillée fournit des instructions étape par étape pour vous aider à exploiter tout le potentiel de Doubao-Seedance-2-0 dans vos projets.

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

Versions de Doubao-Seedance-2-0

La raison pour laquelle Doubao-Seedance-2-0 dispose de plusieurs instantanés peut inclure des facteurs potentiels tels que des variations de sortie après des mises à jour nécessitant des instantanés plus anciens pour la cohérence, offrant aux développeurs une période de transition pour l'adaptation et la migration, et différents instantanés correspondant à des points de terminaison globaux ou régionaux pour optimiser l'expérience utilisateur. Pour les différences détaillées entre les versions, veuillez consulter la documentation officielle.

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

Plus de modèles

Blogs connexes

Apr 17, 2026

Comment utiliser l'API Seedance 2.0

L’API Seedance 2.0 est le tout dernier modèle de génération vidéo multimodale par IA de ByteDance (lancé le 9 avril 2026). Elle accepte du texte, des images, des clips vidéo et de l’audio dans une seule requête afin de produire des vidéos MP4 cinématographiques de 4 à 15 secondes avec une synchronisation audio native, un contrôle de la caméra de niveau réalisateur et une cohérence des mouvements exceptionnelle. Pour l’utiliser : inscrivez-vous sur CometAPI.com, obtenez une clé API, soumettez une tâche asynchrone via REST, interrogez jusqu’à achèvement, puis téléchargez l’URL de la vidéo.

Apr 11, 2026

Qu'est-ce que HappyHorse-1.0 ? Comment comparer Seedance 2.0 ?

Découvrez ce qu’est HappyHorse-1.0, pourquoi il a pris la tête du classement vidéo d’Artificial Analysis, comment il se compare à Seedance 2.0, et ce que les derniers classements signifient pour la génération vidéo par IA.

Mar 24, 2026

Qu’est-ce que Seedance 2.0 ? Une analyse complète

Seedance 2.0 est un modèle de génération vidéo IA multimodal de nouvelle génération développé par ByteDance, capable de générer des vidéos cinématographiques de haute qualité à partir de texte, d’images, d’audio et de vidéos de référence. Il propose une génération conjointe audio-vidéo, une stabilité des mouvements et une édition basée sur des références, et a rapidement grimpé dans les classements mondiaux tels que le leaderboard d’Artificial Analysis, se positionnant parmi les meilleurs modèles vidéo IA en 2026.