API Seedance 2.0 : Un Guide Pratique pour les Développeurs

Dernière mise à jour : mars 2026

L'API Seedance 2.0 permet aux développeurs d'intégrer la génération vidéo par IA directement dans leurs applications. Ce guide couvre ce que fait réellement l'API, comment elle se compare aux alternatives et comment démarrer.

Ce que fait l'API Seedance 2.0

L'API Seedance 2.0 vous donne un accès programmatique pour générer des vidéos à partir de prompts textuels et d'images. Au lieu d'utiliser l'interface web, vous soumettez des tâches de génération via des requêtes HTTP, interrogez l'état d'avancement et récupérez les URLs des vidéos.

Capacités principales :

• Génération texte-vers-vidéo (modèle Seedance 2.0)
• Génération image-vers-vidéo (animer une image de référence)
• Soumission asynchrone de tâches avec interrogation de l'état
• Sortie au format MP4, 1080p HD
• Jusqu'à ~10 secondes par génération

Ce qu'elle ne fait pas :

• Pas de sortie en streaming en temps réel (la génération prend du temps)
• Pas de montage vidéo intégré
• Pas de génération audio (contrairement à Google Veo 3)
• Les temps d'attente dans la file varient selon la charge

API Seedance vs API Concurrentes

Avant de construire, il vaut la peine de comparer honnêtement vos options.

Quand l'API Seedance est pertinente :

• Vous voulez une bonne qualité sans la complexité de configuration de Google Cloud
• Vous construisez un produit qui nécessite une tarification fiable basée sur les crédits
• Vous voulez accéder à plusieurs modèles dans une seule API (Seedance 1.5 pour la vitesse, 2.0 pour la qualité)

Quand envisager des alternatives :

• Besoin de la meilleure qualité possible → Google Veo 3 (Vertex AI)
• Besoin de génération audio native → Google Veo 3
• Besoin de contrôles de caméra avancés → API Runway

Pour Commencer

Étape 1 : Obtenez votre clé API

Inscrivez-vous sur seedance.tv et accédez aux paramètres de votre compte. L'accès à l'API est disponible sur les forfaits payants à partir de 9,9 $/mois.

Stockez votre clé API comme variable d'environnement — ne l'écrivez jamais en dur dans les fichiers source :

export SEEDANCE_API_KEY="votre-clé-api-ici"

Étape 2 : Soumettez une tâche de génération

L'API utilise un modèle asynchrone : vous soumettez une tâche et interrogez l'état jusqu'à la fin.

import requests
import time
import os

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.seedance.tv/v1"

def generate_video(prompt: str, model: str = "seedance-2.0"):
    """Soumettre une tâche de génération texte-vers-vidéo."""
    response = requests.post(
        f"{BASE_URL}/videos",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": model,
            "aspect_ratio": "16:9",
            "resolution": "1080p"
        }
    )
    response.raise_for_status()
    return response.json()["job_id"]

Étape 3 : Interrogez l'état jusqu'à la fin

def wait_for_completion(job_id: str, poll_interval: int = 5, timeout: int = 300):
    """Interroger jusqu'à ce que la génération vidéo soit terminée."""
    start_time = time.time()
    
    while time.time() - start_time < timeout:
        response = requests.get(
            f"{BASE_URL}/videos/{job_id}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        response.raise_for_status()
        data = response.json()
        
        status = data["status"]
        
        if status == "completed":
            return data["output_url"]
        elif status == "failed":
            raise Exception(f"Échec de la génération : {data.get('error', 'Erreur inconnue')}")
        
        # Toujours en cours
        print(f"Statut : {status} ({int(time.time() - start_time)}s écoulées)")
        time.sleep(poll_interval)
    
    raise TimeoutError(f"La génération ne s'est pas terminée dans les {timeout} secondes")

# Utilisation
job_id = generate_video("Un lent travelling avant dans une rue de Tokyo éclairée au néon la nuit, reflets de pluie sur le trottoir mouillé, cinématographique 1080p")
video_url = wait_for_completion(job_id)
print(f"Vidéo prête : {video_url}")

Étape 4 : Image-vers-vidéo

Pour animer une image de référence :

def generate_from_image(image_url: str, prompt: str):
    """Animer une image de référence."""
    response = requests.post(
        f"{BASE_URL}/videos",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": "seedance-2.0",
            "image_url": image_url,
            "type": "image-to-video",
            "aspect_ratio": "16:9"
        }
    )
    response.raise_for_status()
    return response.json()["job_id"]

Ingénierie des Prompts pour l'API

La qualité de votre sortie dépend fortement de la structure du prompt. Voici des modèles qui fonctionnent systématiquement :

Bonne structure de prompt texte-vers-vidéo :

[Type de plan], [Description du sujet], [Action/mouvement], [Environnement], [Éclairage], [Style]

Exemple :

Plan rapproché en travelling, femme marchant dans une oliveraie baignée de soleil, cheveux attrapant la brise, lumière chaude de l'après-midi à travers les feuilles, faible profondeur de champ cinématographique

Erreurs courantes qui gaspillent des crédits API :

Trop vague :

Une belle vidéo

Trop d'éléments concurrents :

Un homme et une femme et un chien à la plage et aussi un coucher de soleil et des vagues et des montagnes en arrière-plan

Description de mouvement manquante :

Une tasse de café sur une table

Mieux : Une tasse de café sur une table en bois, vapeur montant lentement, lumière naturelle douce de la fenêtre à gauche, objectif macro

Choisir le bon modèle :

Flux de travail recommandé : Faites un brouillon avec seedance-1.5, affinez le prompt, puis générez le final avec seedance-2.0. Cela réduit les coûts API pendant l'itération.

Ratios d'Aspect

ASPECT_RATIOS = {
    "landscape": "16:9",   # YouTube, bureau, publicités
    "portrait": "9:16",    # TikTok, Instagram Reels, Shorts
    "square": "1:1",       # Publications Instagram
    "cinema": "21:9"       # Cinémascope
}

Gestion des Erreurs

def safe_generate(prompt: str, max_retries: int = 3):
    """Générer avec logique de réessai pour les échecs transitoires."""
    for attempt in range(max_retries):
        try:
            job_id = generate_video(prompt)
            return wait_for_completion(job_id)
        except requests.HTTPError as e:
            if e.response.status_code == 429:
                # Limité en débit — patienter
                wait = 30 * (attempt + 1)
                print(f"Limité en débit. Attente de {wait}s...")
                time.sleep(wait)
            elif e.response.status_code == 402:
                raise Exception("Crédits insuffisants. Rechargez votre compte sur seedance.tv")
            else:
                raise
        except TimeoutError:
            if attempt < max_retries - 1:
                print(f"Délai d'attente dépassé à la tentative {attempt + 1}, nouvelle tentative...")
            else:
                raise
    raise Exception("Nombre maximal de tentatives dépassé")

Limites de Débit et Utilisation des Crédits

• Limite de débit : Varie selon le forfait. Consultez votre tableau de bord pour les limites actuelles.
• Crédits par génération : Dépend du modèle, de la durée et de la résolution. Le tableau de bord affiche le solde de crédits en direct.
• Meilleure pratique pour la production : Implémentez une file d'attente de tâches plutôt que de soumettre de nombreuses requêtes simultanées. Des soumissions échelonnées évitent les erreurs de limite de débit et sont plus rentables.

Cas d'Utilisation pour Lesquels Cette API est Bien Adaptée

Automatisation de vidéos produits : Plateformes e-commerce générant des vidéos à partir d'images produits à grande échelle. Alimentez une image produit + un prompt de voix de marque → clips vidéo automatisés pour chaque SKU.

Pipelines de médias sociaux : Systèmes de contenu programmé qui génèrent une semaine de contenu vidéo à partir d'une liste de prompts approuvés. Combinez avec un outil de file d'attente vidéo pour une publication sans intervention.

Tests de créations publicitaires : Outils marketing qui génèrent plusieurs interprétations visuelles du même concept pour des tests A/B. Générez 5 variations d'un concept publicitaire en un seul lot.

Génération de prototypes : Équipes de design et de produits générant des vidéos conceptuelles avant de s'engager dans la production. Bien moins cher que la production traditionnelle pour la visualisation en phase précoce.

Construction d'un Pipeline Simple de Génération Vidéo

import json
from pathlib import Path

def batch_generate(prompts: list[dict], output_dir: str = "./videos"):
    """Générer plusieurs vidéos à partir d'une liste de configurations de prompts."""
    Path(output_dir).mkdir(exist_ok=True)
    results = []
    
    for i, config in enumerate(prompts):
        print(f"Génération {i+1}/{len(prompts)} : {config['name']}")
        
        try:
            # Utiliser le modèle rapide pour les brouillons, premium pour les finaux
            model = "seedance-2.0" if config.get("final") else "seedance-1.5"
            job_id = generate_video(config["prompt"], model=model)
            url = wait_for_completion(job_id)
            
            results.append({
                "name": config["name"],
                "url": url,
                "status": "success"
            })
            print(f"  ✓ {url}")
            
        except Exception as e:
            results.append({
                "name": config["name"],
                "error": str(e),
                "status": "failed"
            })
            print(f"  ✗ Échec : {e}")
        
        # Petit délai entre les soumissions
        time.sleep(2)
    
    # Sauvegarder les résultats
    with open(f"{output_dir}/results.json", "w") as f:
        json.dump(results, f, indent=2)
    
    return results

# Exemple d'utilisation
prompts = [
    {"name": "hero-shot", "prompt": "...", "final": True},
    {"name": "product-demo", "prompt": "...", "final": False},
]
results = batch_generate(prompts)

Foire Aux Questions

Seedance 2.0 a-t-il une API publique officielle ?

Seedance propose un accès API dans le cadre des forfaits payants. Consultez la documentation développeur sur seedance.tv pour les détails d'accès actuels et les spécifications des endpoints.

Comment fonctionne la tarification ?

L'utilisation de l'API puise dans votre solde de crédits. Différents modèles coûtent des montants de crédits différents par génération. Consultez votre tableau de bord pour les taux de crédits actuels par modèle.

Quel est le temps de génération par vidéo ?

Généralement de 30 secondes à 3 minutes selon la complexité du modèle et la charge de la file d'attente. Seedance 1.5 est plus rapide ; Seedance 2.0 prend plus de temps mais produit une qualité supérieure.

Puis-je générer des vidéos de plus de 10 secondes ?

Pas avec un seul appel API actuellement. Pour un contenu plus long, générez plusieurs clips et assemblez-les dans votre application en utilisant une bibliothèque de traitement vidéo comme moviepy ou ffmpeg.

La sortie est-elle adaptée à un usage commercial ?

Vérifiez les conditions d'utilisation actuelles sur seedance.tv pour les détails de licence commerciale. Généralement, le contenu généré sur les forfaits payants est sous licence pour un usage commercial.

Comment l'API Seedance se compare-t-elle à l'API Runway ?

L'API Runway (0,05-0,10 $/seconde) offre des contrôles de caméra plus avancés et le modèle Gen-3 Alpha. L'API Seedance utilise une tarification basée sur les crédits, plus prévisible pour la planification budgétaire. Runway l'emporte sur le polissage cinématographique et le contrôle de la caméra ; Seedance l'emporte sur la variété des modèles et la clarté des prix. Pour la plupart des développeurs, essayez les deux sur votre cas d'utilisation spécifique — les résultats varient considérablement selon le type de contenu.

---

Commencez à Construire

Prêt à intégrer la vidéo IA dans votre application ?

Inscrivez-vous sur Seedance → — obtenez des crédits gratuits pour tester l'API, forfaits payants à partir de 9,9 $/mois.

• Bac à sable Texte-vers-Vidéo — testez les prompts avant de construire
• Bac à sable Image-vers-Vidéo — testez l'animation d'image
• Détails du modèle Seedance 2.0 — benchmarks de qualité et spécifications