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

Seedance 2.0 supports multimodal inputs including text prompts, up to 9 images, up to 3 short video clips, and up to 3 audio files, which can be freely combined for rich, controllable generation.

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

Yes — Seedance 2.0 is designed for coherent multi-shot storytelling with consistent characters, visual style, and atmosphere across scenes, reducing common AI video drift issues.

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

Seedance 2.0 can generate cinematic-grade videos (up to 2K resolution) with native audio, synchronized dialogue, and natural motion synthesis, typically in clips of 5–60 seconds.

How does Seedance 2.0 handle audio and lip synchronization?

The model generates audio and video jointly, offering native audio-visual sync with phoneme-level lip sync in 8+ languages for natural speech and sound effects.

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

Yes — Seedance 2.0’s multimodal control, multi-shot continuity, and high fidelity output make it suitable for marketing videos, narrative shorts, ads, and other professional applications.

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

Users can upload reference assets and then describe in natural language how each should influence motion, camera movement, or stylistic elements, giving fine-grained control over the generated content.

Does Seedance 2.0 allow editing and extension of existing videos?

Yes — the model supports video extension and targeted editing like adding scenes, replacing characters, or altering specific segments while preserving unedited portions.

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

Typical output lengths range from ~5 to ~60 seconds per video, and combining many assets or high-resolution settings can increase generation time.

Kimi K3 is now live on CometAPI →

Seedance 2-0

Par Seconde:$0.056

Publié:Apr 19, 2026

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

Populaire

Usage commercial

Playground pour Seedance 2-0

Explorez le Playground de Seedance 2-0 — un environnement interactif pour tester les modèles et exécuter des requêtes en temps réel. Essayez des invites, ajustez les paramètres et itérez instantanément pour accélérer le développement et valider les cas d'utilisation.

Spécifications techniques de Doubao Seedance 2.0

Item	Details
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
Type de sortie	Vidéo MP4
Résolution de sortie	480p, 720p, 1080p
Ratios 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 de génération vidéo multimodale de ByteDance (publié en février 2026). Il utilise une architecture unifiée de co‑génération audio‑vidéo permettant un contrôle précis au niveau d’un réalisateur en se référant simultanément à plusieurs images, clips vidéo et fichiers audio. Il excelle dans la production de vidéos cinématographiques, stables en mouvement, avec une synchronisation audio native — idéal pour les créateurs professionnels ayant besoin d’une physique réaliste, de personnages cohérents et d’une composition de scène complexe.

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, permettant aux utilisateurs de diriger une scène avec des références plus riches qu’un générateur uniquement textuel.
Contrôle de type réalisateur : Le modèle est conçu pour suivre des consignes portant sur le jeu, l’éclairage, les ombres, les mouvements de caméra, le rythme du mouvement 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 l’édition de plans, de personnages, d’actions et d’arcs narratifs spécifiques, ainsi que l’extension vers l’avant/arrière.
Synchronisation audiovisuelle robuste : ByteDance met en avant une sortie stéréo à deux canaux et la synchronisation de la musique de fond, des sons d’ambiance et des voix off pour des résultats plus immersifs.
Haute contrôlabilité pour des scènes complexes : Il met l’accent sur 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 pour le ratio, la durée et le filigrane, ce qui rend le modèle pratique pour des flux de production répétables.

Performances de référence

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

Modes API Seedance 2.0 et Seedance 2.0 Fast 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 forte de la famille Seedance 2.0.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Production plus rapide lorsque l’on peut céder un peu en qualité	Selon ByteDance, il conserve les mêmes capacités que Seedance 2.0, mais génère plus rapidement.
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 est présenté comme un modèle natif de co‑génération audio‑vidéo, tandis que Seedance 2.0 étend la pile de références multimodales et d’édition.

Points forts par rapport aux concurrents :

vs Kling 3.0 : Meilleur contrôle des références multimodales et audio natif.
vs Sora 2 : Précision supérieure des références et prise en charge multi‑plans ; durée maximale légèrement inférieure.
vs Veo 3.1 : Meilleure cohérence des personnages et respect des consignes pour les flux riches en références ; Veo est en tête pour l’étalonnage cinématographique brut et des clips plus longs.

Excelle dans les vidéos centrées sur l’humain et axées sur la performance.

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

Étape 1 : Étape 1 : S’inscrire pour obtenir une clé API

Démarrez directement dans le Playground CometAPI 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éversez vos images de référence, courts clips vidéo ou fichiers audio, ajoutez une consigne descriptive et générez instantanément des vidéos de prévisualisation. C’est le moyen le 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 : Obtenir l’accès à l’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 connexion, accédez à la section API Token de votre console, générez une nouvelle clé et copiez‑la. Visitez ensuite la page de détails du modèle Seedance 2.0 et la documentation API sur CometAPI pour consulter les paramètres pris en charge à intégrer 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 consigne textuelle claire et des fichiers de référence facultatifs (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ée. Vous pourrez ensuite affiner vos consignes, ajuster les paramètres et passer à l’échelle pour des vidéos marketing, des contenus pour les réseaux sociaux, des pipelines vidéo automatisés ou des applications créatives propulsées par Seedance 2.0.

Ce flux de travail vous permet d’expérimenter rapidement dans le Playground et d’assurer 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 facile des paramètres (durée, résolution, format)
Prend en charge les flux texte‑vers‑vidéo et image‑vers‑vidéo
Gestion des tâches intégrée pour la génération vidéo asynchrone

API unifiée et conçue pour les développeurs

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

Tarification avantageuse

CometAPI propose généralement des tarifs à la 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 dépasser votre budget.

Tests rapides avec le Playground

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

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

FAQ

Tarification pour Seedance 2-0

Découvrez des tarifs compétitifs pour 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 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
size	Refer to documentation

*1080p is available for all models except doubao-seedance-2-0-fast

Pricing (Per Second)

Model	480p	720p	1080p	4k
`doubao-seedance-2-0`	$0.056	$0.1216	$0.2992	$0.624
`doubao-seedance-2-0-fast`	$0.0448	$0.096	—	—
`doubao-seedance-1-5-pro`	$0.0192	$0.0416	$0.0928	—
`doubao-seedance-1-0-pro`	$0.0192	$0.0416	$0.0976	—
`doubao-seedance-1-0-pro-fast`	$0.008	$0.016	$0.0384	—

💡 Billed per second. Total cost = price per second × video duration (seconds). Duration range: 4–15 seconds.

Exemple de code et API pour Seedance 2-0

Accédez à des exemples de code complets et aux ressources API pour 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 Seedance 2-0 dans vos projets.

POST

/v1/videos

import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}

def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False

def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600

def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")

def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

headers = {"Authorization": f"Bearer {COMETAPI_KEY}"}

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

    print(f"Status: {status}, progress: {progress}")

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

Python Code Example

import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}


def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False


def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600


def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")


def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

headers = {"Authorization": f"Bearer {COMETAPI_KEY}"}

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

    print(f"Status: {status}, progress: {progress}")

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

JavaScript Code Example

import fs from "fs";
import path from "path";

// Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
const api_key = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const base_url = "https://api.cometapi.com";
const output_dir = "./output";
const poll_interval_ms = 10_000;
const retry_delay_ms = 5_000;
const max_create_attempts = 5;
const max_query_attempts = 3;
const terminal_statuses = new Set(["success", "completed", "failed", "error"]);
const success_statuses = new Set(["success", "completed"]);

function is_progress_complete(progress) {
  if (typeof progress === "number") {
    return progress >= 100;
  }

  if (typeof progress === "string") {
    const numeric = Number(progress.replace(/%$/, ""));
    return Number.isFinite(numeric) && numeric >= 100;
  }

  return false;
}

function is_transient_status(status) {
  return status === 429 || status >= 500;
}

async function fetch_with_retry(url, options, attempts, label) {
  for (let attempt = 1; attempt <= attempts; attempt += 1) {
    const response = await fetch(url, options);
    if (response.ok) {
      return response;
    }

    if (!is_transient_status(response.status) || attempt === attempts) {
      return response;
    }

    console.log(`${label} returned ${response.status}, retrying...`);
    await new Promise((resolve) => setTimeout(resolve, retry_delay_ms));
  }

  throw new Error(`${label} failed`);
}

if (api_key === "<YOUR_COMETAPI_KEY>") {
  console.log("Set COMETAPI_KEY before running this example.");
  process.exit(0);
}

const headers = {
  Authorization: `Bearer ${api_key}`,
};

const form = new FormData();
form.set("prompt", "A slow cinematic camera push across a coastal landscape at sunrise.");
form.set("model", "doubao-seedance-2-0");
form.set("seconds", "5");
form.set("size", "16:9");

const create_response = await fetch_with_retry(`${base_url}/v1/videos`, {
  method: "POST",
  headers,
  body: form,
}, max_create_attempts, "Create request");

if (!create_response.ok) {
  console.log(await create_response.text());
  process.exit(1);
}

const create_result = await create_response.json();
const task_id = create_result.id || create_result.task_id;

if (!task_id) {
  console.log(JSON.stringify(create_result, null, 2));
  process.exit(1);
}

console.log(`Task created: ${task_id}`);
console.log(`Initial status: ${create_result.status}`);

while (true) {
  const task_response = await fetch_with_retry(`${base_url}/v1/videos/${task_id}`, {
    headers,
  }, max_query_attempts, "Status request");

  if (!task_response.ok) {
    console.log(await task_response.text());
    process.exit(1);
  }

  const task = await task_response.json();
  const status = String(task.status || "unknown");
  const normalized_status = status.toLowerCase();
  const progress = task.progress;
  const should_try_download = success_statuses.has(normalized_status) || (
    normalized_status === "unknown" && is_progress_complete(progress)
  );

  console.log(`Status: ${status}, progress: ${progress}`);

  if (should_try_download || terminal_statuses.has(normalized_status)) {
    if (should_try_download) {
      const video_url = task.video_url || "";
      const content_url = `${base_url}/v1/videos/${task_id}/content`;
      const output_path = path.join(output_dir, `${task_id}.mp4`);

      if (!fs.existsSync(output_dir)) {
        fs.mkdirSync(output_dir, { recursive: true });
      }

      const video_response = await fetch(content_url, { headers });
      if (!video_response.ok) {
        console.log(await video_response.text());
        process.exit(1);
      }

      const video_buffer = Buffer.from(await video_response.arrayBuffer());
      fs.writeFileSync(output_path, video_buffer);

      console.log(`Video URL: ${video_url}`);
      console.log(`Content endpoint: ${content_url}`);
      console.log(`Saved to ${output_path}`);
      console.log(`File size: ${fs.statSync(output_path).size} bytes`);
    } else {
      console.log(JSON.stringify(task, null, 2));
      process.exit(1);
    }
    break;
  }

  await new Promise((resolve) => setTimeout(resolve, poll_interval_ms));
}

Curl Code Example

#!/bin/bash

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

if [[ -z "${COMETAPI_KEY:-}" ]]; then
  echo "Set COMETAPI_KEY before running this example."
  exit 0
fi

BASE_URL="https://api.cometapi.com"
OUTPUT_DIR="./output"
POLL_INTERVAL_SECONDS=10
RETRY_DELAY_SECONDS=5
MAX_CREATE_ATTEMPTS=5
MAX_QUERY_ATTEMPTS=3

is_progress_complete() {
  local progress="$1"
  local normalized="${progress%%%}"

  if [[ -z "$normalized" ]]; then
    return 1
  fi

  [[ "$normalized" =~ ^[0-9]+([.][0-9]+)?$ ]] || return 1
  awk -v value="$normalized" 'BEGIN { exit !(value >= 100) }'
}

create_task() {
  local attempt=1
  while (( attempt <= MAX_CREATE_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos" \
      -H "Authorization: Bearer $COMETAPI_KEY" \
      -F 'prompt="A slow cinematic camera push across a coastal landscape at sunrise."' \
      -F 'model="doubao-seedance-2-0"' \
      -F 'seconds="5"' \
      -F 'size="16:9"')

    status_code=$(echo "$response" | tail -n 1)
    CREATE_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_CREATE_ATTEMPTS )); then
      echo "Create request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$CREATE_RESPONSE"
    return 1
  done
}

get_task() {
  local task_id="$1"
  local attempt=1
  while (( attempt <= MAX_QUERY_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos/${task_id}" \
      -H "Authorization: Bearer $COMETAPI_KEY")

    status_code=$(echo "$response" | tail -n 1)
    TASK_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_QUERY_ATTEMPTS )); then
      echo "Status request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$TASK_RESPONSE"
    return 1
  done
}

create_task

TASK_ID=$(echo "$CREATE_RESPONSE" | jq -r '.id // .task_id // empty')

if [[ -z "$TASK_ID" ]]; then
  echo "$CREATE_RESPONSE" | jq .
  echo "No task id returned."
  exit 1
fi

echo "Task created: $TASK_ID"
echo "Initial status: $(echo "$CREATE_RESPONSE" | jq -r '.status // empty')"

while true; do
  get_task "$TASK_ID"

  STATUS=$(echo "$TASK_RESPONSE" | jq -r '.status // empty')
  NORMALIZED_STATUS=$(echo "$STATUS" | tr '[:upper:]' '[:lower:]')
  PROGRESS=$(echo "$TASK_RESPONSE" | jq -r '.progress // empty')
  SHOULD_TRY_DOWNLOAD=0

  if [[ "$NORMALIZED_STATUS" == "success" || "$NORMALIZED_STATUS" == "completed" ]]; then
    SHOULD_TRY_DOWNLOAD=1
  elif [[ "$NORMALIZED_STATUS" == "unknown" ]] && is_progress_complete "$PROGRESS"; then
    SHOULD_TRY_DOWNLOAD=1
  fi

  echo "Status: ${STATUS}, progress: ${PROGRESS}"

  if [[ "$SHOULD_TRY_DOWNLOAD" == "1" || "$NORMALIZED_STATUS" == "failed" || "$NORMALIZED_STATUS" == "error" ]]; then
    if [[ "$SHOULD_TRY_DOWNLOAD" == "1" ]]; then
      VIDEO_URL=$(echo "$TASK_RESPONSE" | jq -r '.video_url // empty')
      CONTENT_URL="${BASE_URL}/v1/videos/${TASK_ID}/content"
      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "$CONTENT_URL" \
        -H "Authorization: Bearer $COMETAPI_KEY" \
        -o "$OUTPUT_PATH"

      if [[ ! -s "$OUTPUT_PATH" ]]; then
        echo "Failed to download video"
        exit 1
      fi

      echo "Video URL: ${VIDEO_URL}"
      echo "Content endpoint: ${CONTENT_URL}"
      echo "Saved to ${OUTPUT_PATH}"
      echo "File size: $(wc -c < "$OUTPUT_PATH" | tr -d ' ') bytes"
    else
      echo "$TASK_RESPONSE" | jq .
      exit 1
    fi
    break
  fi

  sleep "$POLL_INTERVAL_SECONDS"
done

Versions de Seedance 2-0

La raison pour laquelle 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