API Seedance 2.0 : Guide complet d'integration (2026)

L'API Seedance 2.0 offre un acces programmatique au modele de generation video IA de ByteDance. Ce guide couvre tout ce dont les developpeurs ont besoin pour integrer Seedance dans leurs applications et workflows de production, de l'authentification au polling asynchrone en passant par les architectures basees sur les webhooks.

Vue d'ensemble de l'API

L'API REST Seedance 2.0 expose des endpoints pour la generation texte-vers-video, la generation image-vers-video, le polling de statut et la recuperation des resultats. Toute generation est asynchrone : vous soumettez une requete, recevez un identifiant de tache, et interrogez ou attendez un webhook pour obtenir le resultat.

URL de base : https://api.seedance.ai

Format de reponse : Tous les endpoints retournent du JSON avec une structure coherente incluant les champs status, data et error.

Demarrage rapide (5 minutes)

Passez de zero a votre premiere video generee en trois etapes.

Etape 1 : Obtenez votre cle API. Creez un compte sur le portail developpeur Dreamina et accedez a Parametres > Cles API pour generer une cle.

Etape 2 : Soumettez une requete de generation.

curl -X POST https://api.seedance.ai/v2/generate/text \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0",
    "prompt": "A golden retriever running through a field of sunflowers at sunset, slow motion, cinematic lighting",
    "aspect_ratio": "16:9",
    "duration": 4
  }'

Etape 3 : Interrogez le resultat.

curl https://api.seedance.ai/v2/tasks/TASK_ID \
  -H "Authorization: Bearer YOUR_API_KEY"

Lorsque le status retourne "completed", la reponse inclut un champ video_url avec un lien de telechargement signe valide 24 heures.

Authentification

Toutes les requetes API necessitent un token Bearer dans l'en-tete Authorization. Votre cle API est liee a votre compte et votre formule de facturation.

JavaScript

const SEEDANCE_API_KEY = process.env.SEEDANCE_API_KEY

const headers = {
  'Authorization': `Bearer ${SEEDANCE_API_KEY}`,
  'Content-Type': 'application/json',
}

Python

import os
import requests

SEEDANCE_API_KEY = os.environ["SEEDANCE_API_KEY"]

headers = {
    "Authorization": f"Bearer {SEEDANCE_API_KEY}",
    "Content-Type": "application/json",
}

cURL

curl -H "Authorization: Bearer $SEEDANCE_API_KEY" \
     -H "Content-Type: application/json" \
     https://api.seedance.ai/v2/account

Bonnes pratiques de securite :

• Stockez les cles API dans des variables d'environnement, jamais dans le code source
• Renouvelez les cles regulierement via le tableau de bord developpeur
• Utilisez des cles separees pour les environnements de developpement et de production
• Surveillez l'utilisation via le tableau de bord du compte pour detecter les usages non autorises

Endpoint Texte-vers-Video

Generez des videos a partir de descriptions textuelles. C'est l'endpoint principal pour la plupart des cas d'utilisation.

Parametres de la requete :

Exemple JavaScript

async function generateTextToVideo(prompt) {
  const response = await fetch('https://api.seedance.ai/v2/generate/text', {
    method: 'POST',
    headers,
    body: JSON.stringify({
      model: 'seedance-2.0',
      prompt,
      aspect_ratio: '16:9',
      duration: 4,
    }),
  })

  const data = await response.json()

  if (!data.data?.task_id) {
    throw new Error(`Generation echouee : ${data.error?.message ?? 'Erreur inconnue'}`)
  }

  return data.data.task_id
}

Exemple Python

def generate_text_to_video(prompt: str) -> str:
    response = requests.post(
        "https://api.seedance.ai/v2/generate/text",
        headers=headers,
        json={
            "model": "seedance-2.0",
            "prompt": prompt,
            "aspect_ratio": "16:9",
            "duration": 4,
        },
    )
    response.raise_for_status()
    data = response.json()

    task_id = data.get("data", {}).get("task_id")
    if not task_id:
        raise ValueError(f"Generation echouee : {data.get('error', {}).get('message', 'Inconnue')}")

    return task_id

Pour rediger des prompts efficaces, consultez notre guide de prompts Seedance avec plus de 50 modeles prets a l'emploi.

Endpoint Image-vers-Video

Animez des images statiques avec des prompts de mouvement. L'image fournit le point de depart visuel, et le prompt de mouvement decrit comment la scene doit bouger.

Parametres de la requete :

Exemple JavaScript (telechargement de fichier)

async function generateImageToVideo(imagePath, motionPrompt) {
  const imageBuffer = await fs.promises.readFile(imagePath)
  const blob = new Blob([imageBuffer], { type: 'image/png' })

  const formData = new FormData()
  formData.append('model', 'seedance-2.0')
  formData.append('image', blob, 'input.png')
  formData.append('motion_prompt', motionPrompt)
  formData.append('duration', '4')

  const response = await fetch('https://api.seedance.ai/v2/generate/image', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${SEEDANCE_API_KEY}` },
    body: formData,
  })

  const data = await response.json()
  return data.data.task_id
}

Exemple Python

def generate_image_to_video(image_path: str, motion_prompt: str) -> str:
    with open(image_path, "rb") as f:
        files = {"image": ("input.png", f, "image/png")}
        data = {
            "model": "seedance-2.0",
            "motion_prompt": motion_prompt,
            "duration": "4",
        }

        response = requests.post(
            "https://api.seedance.ai/v2/generate/image",
            headers={"Authorization": f"Bearer {SEEDANCE_API_KEY}"},
            files=files,
            data=data,
        )

    response.raise_for_status()
    return response.json()["data"]["task_id"]

Generation asynchrone et polling de statut

Toute generation via l'API Seedance est asynchrone. Apres avoir soumis une requete, vous recevez un task_id et devez interroger le statut jusqu'a completion. Le temps de generation typique est de 30 a 120 secondes selon la duree et la charge du serveur.

Valeurs de statut de tache :

Implementation du polling en JavaScript

async function pollForResult(taskId, maxAttempts = 60, intervalMs = 3000) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const response = await fetch(
      `https://api.seedance.ai/v2/tasks/${taskId}`,
      { headers }
    )
    const data = await response.json()
    const status = data.data?.status

    if (status === 'completed') {
      return data.data.video_url
    }

    if (status === 'failed') {
      throw new Error(`Generation echouee : ${data.data?.error ?? 'Erreur inconnue'}`)
    }

    await new Promise((resolve) => setTimeout(resolve, intervalMs))
  }

  throw new Error('Generation expiree apres le nombre maximum de tentatives de polling')
}

Bonnes pratiques de polling :

• Commencez avec des intervalles de 3 secondes pour les 30 premieres secondes
• Augmentez a 5 secondes apres 30 secondes
• Definissez un timeout maximum de 3 a 5 minutes
• Implementez un backoff exponentiel pour les reponses de limitation de debit

Integration des webhooks

Les webhooks eliminent le besoin de polling en envoyant une notification a votre serveur lorsque la generation est terminee. C'est l'approche recommandee pour les systemes de production.

Configuration des webhooks

// Enregistrer un endpoint webhook
async function registerWebhook(url) {
  const response = await fetch('https://api.seedance.ai/v2/webhooks', {
    method: 'POST',
    headers,
    body: JSON.stringify({
      url,
      events: ['generation.completed', 'generation.failed'],
    }),
  })

  return response.json()
}

Gestionnaire webhook Express.js

app.post('/webhooks/seedance', express.json(), (req, res) => {
  const { event, task_id, video_url, status } = req.body

  if (event === 'generation.completed') {
    // Traiter la video terminee
    processCompletedVideo(task_id, video_url)
  }

  if (event === 'generation.failed') {
    // Gerer l'echec
    handleGenerationFailure(task_id)
  }

  res.status(200).json({ received: true })
})

Securite des webhooks :

• Verifiez l'en-tete de signature du webhook pour confirmer que les requetes proviennent de Seedance
• Utilisez uniquement des endpoints HTTPS
• Repondez avec un statut 200 dans les 5 secondes pour eviter les tentatives
• Implementez un traitement idempotent pour gerer les livraisons en double

Gestion des erreurs

L'API Seedance utilise les codes de statut HTTP standards avec des reponses d'erreur structurees. Une gestion correcte des erreurs est essentielle pour la fiabilite en production.

Codes d'erreur courants :

Limites de debit et quotas

Les limites de debit varient selon la formule et s'appliquent aux requetes simultanees, pas au volume total quotidien.

Construire des workflows de production

Pour les systemes de production generant des videos a grande echelle, implementez un traitement base sur des files d'attente pour gerer la concurrence, traiter les echecs avec elegance et optimiser le debit.

Pattern de traitement par lots

async function processBatch(prompts) {
  const concurrencyLimit = 5
  const results = []

  for (let i = 0; i < prompts.length; i += concurrencyLimit) {
    const batch = prompts.slice(i, i + concurrencyLimit)

    const batchResults = await Promise.allSettled(
      batch.map(async (prompt) => {
        const taskId = await generateTextToVideo(prompt)
        const videoUrl = await pollForResult(taskId)
        return { prompt, videoUrl }
      })
    )

    const settled = batchResults.map((result) =>
      result.status === 'fulfilled'
        ? result.value
        : { error: result.reason.message }
    )

    results.push(...settled)
  }

  return results
}

Pour des informations detaillees sur les tarifs, y compris les remises sur volume, consultez notre guide des tarifs Seedance.

FAQ

Comment obtenir une cle API Seedance ?

Creez un compte sur le portail developpeur Seedance (plateforme Dreamina), accedez a votre tableau de bord et generez une cle API. L'acces API de l'offre gratuite est disponible.

Quels langages de programmation l'API Seedance supporte-t-elle ?

L'API Seedance est une API REST qui fonctionne avec tout langage capable de faire des requetes HTTP. Des exemples officiels sont fournis en JavaScript, Python et cURL.

Combien de temps dure la generation via l'API Seedance ?

La generation prend generalement de 30 a 120 secondes selon les parametres de resolution et de duree. L'API utilise le polling asynchrone pour verifier le statut de la generation.

Quelle est la limite de debit de l'API Seedance ?

Les limites de debit dependent de votre formule. L'offre gratuite autorise environ 2 requetes simultanees, Pro jusqu'a 10, et les formules Business ont des limites personnalisees.

L'API Seedance supporte-t-elle les webhooks ?

Oui. Vous pouvez configurer une URL de webhook pour recevoir des notifications lorsque la generation video est terminee, evitant ainsi le besoin de polling de statut.

Puis-je utiliser l'API Seedance pour des projets commerciaux ?

Oui. L'utilisation de l'API avec les formules Pro et Business inclut une licence commerciale. Consultez les conditions d'utilisation pour les droits d'utilisation specifiques.

Articles connexes

• Tutoriel Seedance 2.0 — Guide complet pour debutants sur Seedance
• Guide de prompts Seedance — Plus de 50 modeles de prompts pour de meilleurs resultats API
• Tarifs Seedance — Niveaux tarifaires API et remises sur volume
• Seedance vs Sora 2026 — Comparaison API avec OpenAI Sora