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.

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 seule façon de générer des vidéos Seedance 2.0 était via la console web. Si vous avez vu des tutoriels présentant une démonstration de l'interface utilisateur, ceux-ci ont été écrits pour la console. Ce guide couvre l'API réelle que les développeurs peuvent appeler de manière programmatique.

💡

L'API suit un modèle de tâche asynchrone : POST pour créer une tâche, recevoir un ID de tâche, puis interroger un point de terminaison GET jusqu'à ce que la tâche soit terminée. Ce modèle mérite d'être testé de bout en bout avant le déploiement. Les scénarios de test d'Apidog vous permettent d'enchaîner la soumission POST, d'extraire l'ID de tâche, de boucler l'interrogation GET et de vérifier que la réponse finale contient une URL vidéo valide. Téléchargez Apidog gratuitement pour suivre les étapes de test dans la section Apidog ci-dessous.

Cet article couvre chaque type d'entrée pris en charge, le calcul des prix à partir du nombre de jetons de réponse et les erreurs que vous rencontrerez en production.

Qu'est-ce que Seedance 2.0 ?

Seedance 2.0 est un modèle de génération vidéo de ByteDance. Il fonctionne sur Volcengine Ark sous les ID de modèle doubao-seedance-2-0-260128 (standard) et doubao-seedance-2-0-fast-260128 (plus rapide, qualité inférieure).

Le modèle prend en charge plus de types d'entrée que la version 1.5. La version 1.5 gérait le texte-vers-vidéo et l'image-vers-vidéo. La version 2.0 ajoute :

Contrôle de la première et de la dernière image (vous fournissez les deux images de début et de fin)
Entrées de référence multimodales : images, clips vidéo et fichiers audio combinés en une seule requête
Génération audio native, y compris les dialogues, les effets sonores, les sons d'ambiance et la musique
Synchronisation labiale dans plus de 8 langues
Contrôle du mouvement de la caméra par des invites en langage naturel (travelling, panoramique, grues)
Sortie jusqu'à 15 secondes avec une résolution allant jusqu'à 2K

Le modèle produit des vidéos à 24 ips avec des rapports d'aspect allant de 1:1 à 21:9. Vous choisissez la résolution au moment de la requête.

Ce qui a changé : guide vs API officielle

Les articles précédents sur Seedance 2.0, y compris un guide de février 2026 sur ce site, décrivaient la console web Seedance 2.0 sur Volcengine. Aucune API n'existait à ce moment-là. Ces guides expliquaient comment remplir un champ d'invite sur une page web et cliquer sur un bouton de génération.

La publication de l'API le 2 avril 2026 change cela entièrement. Vous pouvez désormais appeler l'API depuis n'importe quel langage, automatiser les pipelines de génération vidéo et intégrer Seedance dans votre propre produit. Ce guide remplace la démonstration de l'interface utilisateur pour tout cas d'utilisation de développeur.

Prérequis

Vous avez besoin d'un compte Volcengine pour commencer. Créez-en un sur volcengine.com. Une fois votre compte actif, accédez à la console Ark à l'adresse :

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

Générez une clé API là-bas. Exportez-la ensuite comme variable d'environnement :

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

Chaque requête à l'API utilise cette clé dans un en-tête de jeton Bearer :

Authorization: Bearer YOUR_ARK_API_KEY

Les nouveaux comptes reçoivent des crédits d'essai gratuits. Ceux-ci couvrent environ 8 générations complètes de 15 secondes en 1080p avant que vous ne payiez quoi que ce soit.

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

L'URL de base pour tous les appels de l'API Seedance est :

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

Pour soumettre une tâche texte-vers-vidéo, effectuez une requête 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
  }'

L'API renvoie immédiatement un ID de tâche :

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

Exemple Python (SDK officiel)

Installez d'abord le SDK :

pip install volcenginesdkarkruntime

Puis 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 la tâche. Vous en aurez besoin pour l'étape d'interrogation.

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

La génération Seedance n'est pas instantanée. Une vidéo 1080p de 5 secondes prend généralement de 60 à 120 secondes. L'API gère cela avec un cycle de vie de tâche asynchrone :

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

Vous interrogez le point de terminaison GET jusqu'à ce que le statut passe de queued (en file d'attente) ou running (en cours).

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 : interroger avec un 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)  # plafonner à 60 secondes

# É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 empêche de surcharger l'API. Le plafonnement à 60 secondes maintient l'interrogation suffisamment fréquente pour une utilisation pratique.

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

Pour animer une image, ajoutez un objet image_url au tableau content à côté de votre invite textuelle. 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 sur "adaptive" indique au modèle d'utiliser le rapport d'aspect natif de l'image d'entrée. Cela évite le recadrage ou le letterboxing indésirables.

Chaque image doit faire moins de 30 Mo. Vous pouvez fournir jusqu'à 9 images dans une seule requête.

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

Seedance 2.0 prend en charge le contrôle des images de début et de fin. Vous fournissez l'image de la première image, l'image de la dernière image et une invite textuelle. Le modèle génère le mouvement intermédiaire.

Ceci est utile pour les transitions de produits, les effets de morphing ou toute séquence où vous connaissez vos états de début et de fin.

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,
)

Le modèle déduit que deux images signifient le mode première et dernière image lorsqu'une invite textuelle est également présente. Incluez les deux images dans l'ordre : première image d'abord, dernière image ensuite.

Vous pouvez également utiliser return_last_frame: true lors de la génération d'un clip. Cela renvoie une image de la dernière image avec l'URL de la vidéo. Utilisez cette image comme première image de votre prochaine requête pour enchaîner plusieurs clips en une séquence plus longue.

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

L'une des plus grandes nouveautés de Seedance 2.0 est l'acceptation de vidéos et d'audio comme entrées de référence dans la même requête que les images et le texte.

Le tableau de contenu peut contenir :

{"type": "text", "text": "..."} pour l'invite
{"type": "image_url", "image_url": {"url": "..."}} pour les images
{"type": "video_url", "video_url": {"url": "..."}} pour les références vidéo
{"type": "audio_url", "audio_url": {"url": "..."}} pour les références audio

Limites par requête :

Jusqu'à 9 images (max 30 Mo chacune)
Jusqu'à 3 clips vidéo (de 2 à 15 secondes chacun, max 50 Mo chacun)
Jusqu'à 3 fichiers audio (MP3, max 15 Mo chacun)

Un exemple de référence combinée :

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,
)

Lorsque vous incluez une référence vidéo, le tarif de facturation tombe au niveau V2V : environ 3,90 $ par million de jetons au lieu de 6,40 $.

Génération audio native

Définissez generate_audio: true pour que Seedance génère une piste audio en même temps que la vidéo. Le modèle effectue une génération audio-vidéo conjointe, de sorte que les sons correspondent à l'action à l'écran plutôt que d'être ajoutés après coup.

La génération audio couvre les dialogues, les effets sonores, le bruit ambiant et la musique de fond. La synchronisation labiale fonctionne dans plus de 8 langues.

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 native augmente légèrement la consommation de jetons par rapport à une vidéo silencieuse. Tenez-en compte dans vos estimations de coûts.

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

Trois paramètres définissent la sortie :

**resolution** accepte "480p", "720p", "1080p", ou "2K". La valeur par défaut est "1080p". Une résolution plus élevée signifie plus de jetons consommés et un coût plus élevé.

**ratio** accepte "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", ou "adaptive". Utilisez "adaptive" lorsque votre image d'entrée a un rapport d'aspect inhabituel. Le modèle lit les dimensions de l'image et définit le rapport en conséquence.

**duration** accepte des entiers de 4 à 15. L'unité est la seconde. La valeur par défaut est 5. Les vidéos plus longues coûtent proportionnellement plus cher.

Le modèle rapide (doubao-seedance-2-0-fast-260128) génère une qualité inférieure mais se termine plus rapidement. Utilisez-le pour le prototypage ou lorsque vous itérez sur des invites. Passez au modèle standard pour la production finale.

Quand choisir Seedance 2.0 par rapport à d'autres API vidéo : choisissez Seedance lorsque vous avez besoin d'une génération audio-vidéo conjointe native, d'un contrôle des images de début et de fin, ou d'entrées de référence multimodales. Si vous n'avez besoin que d'un simple texte-vers-vidéo et que le coût est la priorité, le modèle rapide à 480p est l'option la moins chère de cette catégorie.

Lire le coût de la réponse

Une fois qu'une tâche a réussi, la réponse inclut un champ usage :

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

La consommation de jetons est corrélée à la durée et à la résolution de la vidéo. Un point de référence des documents officiels : une vidéo 1080p de 15 secondes consomme environ 308 880 jetons. Une vidéo 1080p de 5 secondes utilise environ 102 960 jetons.

Le prix pour T2V et I2V en 1080p est de 46 yuans par million de jetons (environ 6,40 $ par million de jetons aux taux de change actuels).

Estimations rapides :

Vidéo 1080p de 5 secondes : environ 102 960 jetons = environ 0,47 yuan = environ 0,93 $
Vidéo 1080p de 10 secondes : environ 205 920 jetons = environ 9,47 yuans = environ 1,97 $

Pour les tâches V2V (requêtes incluant une référence vidéo), le taux tombe à 28 yuans par million de jetons (environ 3,90 $ par million de jetons).

Vous pouvez vérifier le nombre exact de jetons sur chaque réponse et intégrer le suivi des coûts dans votre application. Multipliez completion_tokens par le taux correspondant à votre type de tâche.

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

L'video_url dans une réponse réussie pointe vers le stockage d'objets Volcengine. Cette URL expire 24 heures après le succès de la tâche. Après cela, l'URL renvoie une erreur 403 et le fichier est supprimé.

Téléchargez toujours le fichier vers votre propre stockage immédiatement après que le statut passe à succeeded (réussi). La boucle d'interrogation de la section précédente inclut cette étape de téléchargement dans le flux standard.

Le champ execution_expires_after confirme la fenêtre d'expiration en secondes. 172800 signifie 48 heures pour l'enregistrement de la tâche elle-même. L'URL de la vidéo expire toujours après 24 heures, quoi qu'il arrive. Fiez-vous à la règle des 24 heures.

L'historique des tâches est également limité aux 7 derniers jours. Vous ne pouvez pas interroger des tâches plus anciennes.

Comment tester l'API Seedance avec Apidog

Le modèle de tâche asynchrone comporte deux appels d'API qui dépendent l'un de l'autre. Vous ne pouvez pas écrire un test à requête unique pour cela. Les scénarios de test d'Apidog gèrent cela avec un flux enchaîné.

Voici la configuration exacte :

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

Dans Apidog, accédez au module Tests et créez un nouveau scénario appelé "Génération de vidéo Seedance 2.0". Définissez votre variable d'environnement ARK_API_KEY dans les paramètres d'environnement d'Apidog. Utilisez {{ARK_API_KEY}} partout où vous feriez référence à la clé.

Étape 2 : Ajouter la requête de soumission

Ajoutez une étape de requête POST personnalisée à https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks. Définissez l'en-tête Authorization sur Bearer {{ARK_API_KEY}}. Ajoutez votre corps JSON avec les champs `model` et `content`.

Après cette étape, ajoutez un processeur d'extraction de variable. Configurez-le pour extraire du corps de la réponse en utilisant l'expression JSONPath $.id. Enregistrez la valeur dans une variable d'environnement appelée TASK_ID.

Étape 3 : Ajouter un processeur d'attente

Insérez un processeur d'attente après l'étape d'extraction. Définissez le délai à 30 secondes. Cela donne au modèle le temps de commencer le traitement avant votre première tentative d'interrogation.

Étape 4 : Ajouter la requête d'interrogation dans une boucle For

Ajoutez un bloc de contrôle de boucle For avec un maximum de 20 itérations. À l'intérieur de la boucle :

Ajoutez une étape de requête GET à https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks/{{TASK_ID}} avec le même en-tête Authorization.
Ajoutez un processeur d'attente avec un délai de 10 secondes après la requête GET.
Définissez la condition de rupture de la boucle sur : $.status == "succeeded" ou $.status == "failed".

Étape 5 : Ajouter des assertions

Une fois la boucle terminée, ajoutez un processeur d'assertion qui vérifie :

$.status est égal à "succeeded"
$.content.video_url n'est pas vide

Exécutez le scénario et Apidog génère un rapport de test complet montrant chaque étape, l'ID de tâche extrait, toutes les réponses d'interrogation et si les assertions finales ont réussi.

Vous pouvez également importer les points de terminaison Seedance directement à partir d'une commande cURL dans les étapes du scénario de test. Cette approche fonctionne bien lorsque vous souhaitez ajouter rapidement les requêtes de soumission et d'interrogation sans saisir manuellement chaque en-tête et paramètre.

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

L'API Seedance utilise une tarification au jeton basée sur la consommation. Il n'y a pas de forfaits mensuels ou de crédits à gérer au-delà du solde d'essai initial.

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

Coûts approximatifs pour les durées courantes 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 nouveaux comptes commencent avec des crédits d'essai gratuits couvrant environ 8 générations complètes de 15 secondes. Utilisez cette allocation pour expérimenter les invites et les paramètres avant de vous engager dans une charge de travail de production.

Une résolution plus faible réduit considérablement la consommation de jetons. Une vidéo 480p de même durée coûte considérablement moins cher qu'une vidéo 1080p. Commencez le développement en 720p, puis n'augmentez la résolution que pour votre sortie finale.

Erreurs courantes et solutions

429 Trop de requêtes

Cela signifie que vous avez atteint la limite de concurrence, et non une limite de débit sur les requêtes par minute. Trop de tâches s'exécutent simultanément. Utilisez un backoff exponentiel lorsque vous voyez ce code d'état. Commencez par une attente de 10 secondes et doublez-la à chaque nouvelle tentative, avec un plafond de 60 secondes. La boucle d'interrogation montrée précédemment inclut ce modèle.

statut : "failed" (échec)

Une tâche échouée signifie que le modèle n'a pas pu générer la vidéo. Causes courantes : l'invite contenait du contenu qui violait les filtres de sécurité, l'image d'entrée était corrompue ou trop grande, ou la combinaison de paramètres était invalide. Vérifiez vos fichiers d'entrée et votre invite, puis soumettez à nouveau.

statut : "expired" (expiré)

Une tâche expire si elle reste trop longtemps en file d'attente sans se terminer. Cela peut arriver pendant les périodes de forte charge. Soumettez à nouveau la tâche. Il n'y a aucun moyen de redémarrer une tâche expirée.

403 sur video_url

L'URL a expiré. La fenêtre de 24 heures s'est écoulée avant que vous ne téléchargiez le fichier. L'enregistrement de la tâche peut encore exister dans l'API jusqu'à 7 jours, mais le fichier vidéo est parti. Vous devrez le régénérer en utilisant les mêmes paramètres et la même valeur de seed si vous l'avez sauvegardée.

Reproductibilité du seed

Si vous avez enregistré la valeur seed d'une réponse précédente, transmettez-la dans la requête suivante avec les mêmes paramètres. Le modèle tentera de reproduire la même sortie. Ceci est utile pour régénérer des vidéos expirées avec des résultats identiques.

Conclusion

L'API Seedance 2.0 vous donne un accès programmatique à l'un des modèles de génération vidéo les plus performants disponibles aujourd'hui. Le modèle de tâche asynchrone est simple : POST pour créer une tâche, interroger jusqu'à la réussite, télécharger immédiatement. Les entrées multimodales, la génération audio native et le contrôle des images de début et de fin permettent de créer des workflows vidéo qui étaient impossibles depuis une console web.

Mettez en place votre couverture de test dans Apidog avant de passer en production. La chaîne de scénarios de test détecte les logiques d'interrogation erronées, les étapes d'extraction manquantes et les problèmes d'expiration d'URL avant qu'ils n'affectent les utilisateurs réels.

button

FAQ

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

Le modèle standard produit une sortie de meilleure qualité et est la valeur par défaut pour la production. Le modèle rapide termine les tâches plus rapidement avec une qualité visuelle inférieure. Utilisez le modèle rapide lors de l'itération sur les invites et passez au standard pour les rendus finaux.

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

Le point de terminaison de l'API est hébergé dans la région de Pékin. Les développeurs en dehors de la Chine peuvent l'appeler, mais la latence sera plus élevée. Vérifiez les conditions d'utilisation de Volcengine pour toute restriction géographique sur votre type de compte.

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

Définissez return_last_frame: true sur chaque génération. La réponse inclura une image de la dernière image ainsi que l'URL de la vidéo. Passez cette image comme première image de votre prochaine requête. Répétez l'opération jusqu'à ce que vous ayez tous les clips nécessaires, puis assemblez-les à l'aide d'une bibliothèque de montage vidéo.

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

La génération audio native augmente légèrement la consommation de jetons car le modèle effectue une génération audio-vidéo conjointe plutôt qu'une vidéo uniquement. Attendez-vous à une légère augmentation des completion_tokens par rapport à la même requête sans generate_audio: true.

Q : Puis-je configurer un webhook au lieu d'interroger ?

Oui. Passez un paramètre callback_url dans votre requête de soumission. L'API POSTera le résultat de la tâche terminée à cette URL lorsque le statut changera. C'est plus efficace que l'interrogation pour les pipelines à fort volume.

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

L'API renvoie une erreur de validation 400 avant la création de la tâche. Réduisez le nombre d'images dans votre tableau de contenu à 9 ou moins.

Q : Le paramètre seed garantit-il de reproduire exactement la même vidéo ?

Le paramètre seed rend les sorties plus reproductibles. Une reproduction exacte n'est pas garantie si les paramètres diffèrent ou si les versions du modèle côté serveur changent. C'est l'approximation la plus proche disponible.

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

Lisez le champ completion_tokens de la réponse de chaque tâche et multipliez-le par le taux de jetons de votre niveau. Enregistrez ces valeurs dans une base de données pour le suivi des coûts. Il n'y a pas de tableau de bord de dépenses intégré dans l'API, alors construisez votre propre suivi dès le début.