Comment Utiliser l'API Seedance 2.0 en 2026

En bref

L'API Seedance 2.0 a été lancée le 2 avril 2026 via Volcengine Ark. Vous soumettez une tâche de génération de vidéo avec une requête POST, puis interrogez un point de terminaison GET jusqu'à ce que le statut atteigne "succeeded" (réussi). L'API prend en charge le texte-vers-vidéo, l'image-vers-vidéo, le contrôle de la première et de la dernière image, les références multimodales et la génération audio native. Une vidéo de 1080p de 5 secondes coûte environ 0,93 $. Téléchargez la vidéo dans les 24 heures. L'URL expire après cela.

Essayez Apidog dès aujourd'hui

Hypereal AI

Essayer Hypereal AI

Introduction

Le 2 avril 2026, la plateforme Volcengine Ark de ByteDance a publié l'API officielle Seedance 2.0. Avant cette date, la génération de vidéos Seedance 2.0 se faisait uniquement via la console web. Les tutoriels web existants concernaient l'interface utilisateur. Ce guide détaille l'usage direct de l'API pour l'intégration développeur.

💡 L'API applique un modèle de tâche asynchrone : POST pour créer, ID de tâche reçu, puis interrogation GET jusqu'à complétion. Testez ce workflow de bout en bout avant la mise en production. Les scénarios de test Apidog permettent d’enchaîner la soumission POST, d’extraire l’ID de tâche, de boucler l’interrogation GET et de vérifier la présence d’une URL vidéo valide. Utilisez Apidog pour suivre les étapes pratiques décrites plus bas.

Cet article couvre chaque type d'entrée, le calcul du coût à partir du nombre de jetons et la gestion des erreurs courantes.

Qu'est-ce que Seedance 2.0 ?

Seedance 2.0 est un modèle de génération vidéo de ByteDance fonctionnant sur Volcengine Ark avec les IDs :

• doubao-seedance-2-0-260128 (standard)
• doubao-seedance-2-0-fast-260128 (rapide, qualité inférieure)

Nouveautés par rapport à la version 1.5 :

• Contrôle de la première et dernière image
• Références multimodales (images, clips vidéo, fichiers audio dans une même requête)
• Génération audio native (dialogues, SFX, musique, ambiance)
• Synchronisation labiale multilingue (8+ langues)
• Contrôle du mouvement caméra par prompts
• Jusqu’à 15 secondes, résolution jusqu’à 2K

Production en 24 ips, ratios de 1:1 à 21:9. Choisissez la résolution lors de la requête.

Ce qui a changé : guide vs API officielle

Les anciens guides Seedance 2.0 (par exemple ce guide de février 2026) expliquaient la console web, sans API. Maintenant, vous pouvez :

• Appeler l’API depuis n’importe quel langage
• Automatiser la génération vidéo
• Intégrer Seedance dans vos produits

Ce guide est la référence pour tout usage développeur.

Prérequis

1. Créez un compte Volcengine sur volcengine.com
2. Accédez à la console Ark :

   https://console.volcengine.com/ark/region:ark+cn-beijing/apikey

1. Générez une clé API et exportez-la :

   export ARK_API_KEY="your-api-key-here"

1. Utilisez la clé dans l’en-tête Bearer :

   Authorization: Bearer YOUR_ARK_API_KEY

Les nouveaux comptes reçoivent des crédits gratuits (environ 8 générations complètes de 15s en 1080p).

Texte-vers-vidéo : votre première requête

L’URL de base API :

https://ark.cn-beijing.volces.com/api/v3

Soumission POST vers /v1/contents/generations/tasks.

Exemple cURL

curl -X POST "https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
      }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false
  }'

Réponse immédiate avec ID de tâche :

{"id": "cgt-2025xxxxxxxx-xxxx"}

Exemple Python (SDK officiel)

Installez le SDK :

pip install volcenginesdkarkruntime

Soumettez une tâche :

import os
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

print(resp.id)

Stockez l’ID de tâche pour l’interrogation suivante.

Le modèle de tâche asynchrone : soumettre, interroger, télécharger

La génération n’est pas instantanée (60 à 120s pour 5s en 1080p). Cycle de vie :

queued -> running -> succeeded
                 -> failed
                 -> expired
                 -> cancelled

Interrogez le point de terminaison GET jusqu’à obtention de succeeded.

Boucle d’interrogation Python complète

import os
import time
import requests
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

# Étape 1 : soumettre
resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {"type": "text", "text": "Aerial shot of a mountain lake at sunrise, slow dolly forward"}
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

task_id = resp.id
print(f"Tâche soumise : {task_id}")

# Étape 2 : interrogation avec backoff exponentiel
wait = 10
while True:
    result = client.content_generation.tasks.get(task_id=task_id)
    status = result.status
    print(f"Statut : {status}")

    if status == "succeeded":
        video_url = result.content.video_url
        print(f"URL de la vidéo : {video_url}")
        break
    elif status in ("failed", "expired", "cancelled"):
        print(f"Tâche terminée avec le statut : {status}")
        break

    time.sleep(wait)
    wait = min(wait * 2, 60)  # max 60s

# Étape 3 : télécharger immédiatement
if status == "succeeded":
    response = requests.get(video_url, stream=True)
    with open("output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Téléchargé : output.mp4")

Le backoff exponentiel évite de surcharger l’API.

Image-vers-vidéo (I2V) : animer une image fixe

Pour animer une image, ajoutez un objet image_url au tableau content avec votre texte. L’image devient la première image de la vidéo.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The woman slowly turns her head and smiles at the camera"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/portrait.jpg"}
        }
    ],
    ratio="adaptive",
    duration=5,
    watermark=False,
)

Définir ratio à "adaptive" pour utiliser le ratio natif de l’image. Max 30 Mo/image, jusqu’à 9 images/requête.

Première et dernière image : contrôle des points de début et de fin

Vous pouvez fournir la première et la dernière image + une invite textuelle pour générer le mouvement intermédiaire.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The flower blooms from bud to full open, macro lens, soft light"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-bud.jpg"}
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-open.jpg"}
        }
    ],
    ratio="adaptive",
    duration=8,
    watermark=False,
)

Incluez les deux images dans l’ordre : première image, puis dernière image. Utilisez return_last_frame: true pour chaîner plusieurs clips.

Référence multimodale : combiner images, vidéo et audio

Seedance 2.0 accepte images, vidéos et audio en entrée.

Types de contenu possibles :

• {"type": "text", ...}
• {"type": "image_url", ...}
• {"type": "video_url", ...}
• {"type": "audio_url", ...}

Limites :

• Jusqu’à 9 images (30 Mo chacune)
• 3 clips vidéo (2-15s, 50 Mo chacun)
• 3 fichiers audio (MP3, 15 Mo chacun)

Exemple :

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "Match the visual style of the reference clip and add the provided background audio"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/style-reference.jpg"}
        },
        {
            "type": "video_url",
            "video_url": {"url": "https://example.com/motion-reference.mp4"}
        },
        {
            "type": "audio_url",
            "audio_url": {"url": "https://example.com/background-music.mp3"}
        }
    ],
    duration=10,
    ratio="16:9",
    watermark=False,
)

Inclure une référence vidéo réduit le coût (voir section prix).

Génération audio native

Activez generate_audio: true pour générer l’audio en même temps que la vidéo (dialogues, bruitages, musique, ambiance).

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A street musician plays guitar outside a cafe in Paris, crowds passing by, city sounds"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=10,
    generate_audio=True,
    watermark=False,
)

La génération audio augmente légèrement la consommation de jetons.

Contrôler la résolution, le rapport d’aspect et la durée

• resolution : "480p", "720p", "1080p", "2K" (défaut : "1080p")
• ratio : "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", "adaptive"
• duration : entier de 4 à 15 (secondes, défaut : 5)

Le modèle rapide (doubao-seedance-2-0-fast-260128) est utile pour le prototypage.

Cas d'usage Seedance 2.0 :

• Génération audio-vidéo native
• Contrôle images début/fin
• Références multimodales

Lire le coût de la réponse

Une fois la tâche réussie, le champ usage indique la consommation de jetons :

{
  "usage": {
    "completion_tokens": 246840,
    "total_tokens": 246840
  }
}

Références :

• 1080p, 15s ≈ 308 880 jetons
• 1080p, 5s ≈ 102 960 jetons

Tarifs :

• T2V/I2V 1080p : 46 yuans/Mjetons (~6,40 $)
• V2V : 28 yuans/Mjetons (~3,90 $)

Calculez le coût : completion_tokens × tarif unitaire.

Important : téléchargez la vidéo dans les 24 heures

Le video_url expire après 24h. Après expiration : erreur 403, fichier supprimé. Téléchargez immédiatement à la complétion.

• execution_expires_after donne la durée d’enregistrement de la tâche (172800s = 48h), mais l’URL vidéo = 24h max.
• Historique des tâches limité à 7 jours.

Comment tester l'API Seedance avec Apidog

Le modèle asynchrone requiert plusieurs appels dépendants. Apidog permet de chaîner ces étapes.

Étape 1 : Créer un scénario de test

• Dans Apidog, module Tests → nouveau scénario "Génération de vidéo Seedance 2.0"
• Définissez la variable d’environnement ARK_API_KEY dans les paramètres
• Utilisez {{ARK_API_KEY}} dans les requêtes

Étape 2 : Requête de soumission

• Ajoutez une requête POST vers https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks
• Header Authorization : Bearer {{ARK_API_KEY}}
• Corps JSON avec model et content
• Ajoutez un extracteur JSONPath $.id vers une variable TASK_ID

Étape 3 : Processeur d'attente

• Ajoutez un délai de 30s après l’extraction

Étape 4 : Requête d’interrogation en boucle For

• Ajoutez un bloc For (max 20 itérations) :
  1. GET sur https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks/{{TASK_ID}}
  2. Attente 10s
  3. Condition de sortie : $.status == "succeeded" ou $.status == "failed"

Étape 5 : Assertions

• Vérifiez que $.status == "succeeded" et que $.content.video_url n’est pas vide

Exécutez le scénario pour obtenir un rapport détaillé de chaque étape. Vous pouvez importer les endpoints Seedance directement depuis une commande cURL.

Détail des prix : combien coûte une vidéo de 10 secondes

La tarification est purement à la consommation de jetons.

Type de tâche	Tarif (pour 1M de jetons)
T2V / I2V en 1080p	46 yuans (~6,40 $)
V2V (entrée vidéo)	28 yuans (~3,90 $)

Coûts typiques en 1080p :

Durée	Jetons approx.	Coût (T2V/I2V)
5 secondes	~103,000	~0,66 yuan / ~0,93 $
10 secondes	~206,000	~9,48 yuans / ~1,32 $
15 secondes	~309,000	~14,21 yuans / ~1,97 $

Les crédits d’essai couvrent ≈8 générations complètes de 15s. Pour réduire le coût, commencez en 720p ou 480p.

Erreurs courantes et solutions

429 Trop de requêtes

• Limite de concurrence atteinte (trop de tâches en parallèle). Implémentez un backoff exponentiel (départ 10s, doublez jusqu’à 60s max).

Statut "failed"

• Invite non conforme, image corrompue/trop grande, paramètres invalides. Vérifiez et resoumettez.

Statut "expired"

• Tâche trop longtemps en file d’attente. Resoumettez, pas de redémarrage possible.

403 sur video_url

• L’URL a expiré (24h dépassées). Fichier supprimé. Régénérez avec les mêmes paramètres/seed.

Reproductibilité avec seed

• Passez la valeur seed pour tenter de reproduire une vidéo identique.

Conclusion

L’API Seedance 2.0 permet une génération vidéo avancée, automatisable et multimodale. Modèle asynchrone simple : POST, interrogation GET, téléchargement immédiat. Les tests automatisés avec Apidog garantissent la robustesse de vos workflows avant déploiement réel.

FAQ

Q : Quelle est la différence entre doubao-seedance-2-0-260128 et doubao-seedance-2-0-fast-260128 ?

Le modèle standard offre une meilleure qualité pour la production. Le modèle rapide est utile pour le prototypage, mais la qualité visuelle est inférieure.

Q : Puis-je utiliser Seedance 2.0 en dehors de la Chine ?

Oui, même si l’API est hébergée à Pékin (latence accrue possible). Vérifiez les conditions Volcengine selon votre compte.

Q : Comment enchaîner plusieurs clips pour une vidéo longue ?

Activez return_last_frame: true pour chaque génération. Passez la dernière image comme première image du clip suivant. Assemblez les vidéos en post-production.

Q : La génération audio native coûte-t-elle plus cher ?

Oui, légèrement, car la génération audio-vidéo conjointe consomme plus de jetons.

Q : Peut-on recevoir un webhook au lieu d’interroger ?

Oui, ajoutez callback_url lors de la soumission. L’API POSTera le résultat à cette URL.

Q : Que se passe-t-il si je dépasse la limite de 9 images ?

Erreur 400 (validation). Réduisez à 9 images ou moins.

Q : Le paramètre seed garantit-il une reproduction exacte ?

Pas à 100 %, mais la sortie sera très proche, sauf changement de version serveur ou de paramètres.

Q : Comment suivre les dépenses sur plusieurs tâches ?

Lisez completion_tokens dans chaque réponse, multipliez par le tarif, stockez dans une base de données. Pas de dashboard intégré : implémentez votre suivi dès le début.