API Seedance 2.0 : comment générer des vidéos IA par programmation

Générez une vidéo cinématographique par IA avec une seule requête HTTP. L'API Seedance 2.0 repose sur le même pipeline de génération que la plateforme web, exposé sous forme d'interface REST propre avec authentification Bearer, webhooks et endpoints de traitement par lots. Si vous savez faire une requête POST, vous pouvez construire un pipeline de génération vidéo.

Ce guide couvre tout ce dont vous avez besoin pour intégrer Seedance 2.0 dans vos propres applications : authentification, endpoints, paramètres, gestion des erreurs et exemples de code prêts pour la production en Python et JavaScript.

En bref : l'API d'un coup d'œil

• URL de base : https://api.arteza.ai/v1
• Auth : Token Bearer dans l'en-tête Authorization
• Génération : Asynchrone : soumettez une tâche, interrogez l'état ou utilisez un webhook pour être notifié
• Limites de débit : 60 requêtes par minute, 5 générations simultanées
• Modèles : Seedance 2.0, 1.0 Pro, 1.0 Lite, Seedream v3/v4.5/v5, tous accessibles via une seule API
• Coût en crédits : Même tarification dynamique à la seconde que l'interface web (19-351 crédits pour la version 2.0)

Ce que l'API peut réellement faire

Tout ce que fait l'interface web, l'API le fait aussi. Texte vers vidéo, image vers vidéo, sélection de modèle, contrôle de la durée, format d'image, activation de l'audio et accès à tous les modèles de la plateforme. Des endpoints de traitement par lots pour générer de nombreux clips en une seule fois. Des notifications par webhook pour ne pas avoir à interroger l'état manuellement. Des métadonnées personnalisées renvoyées dans les résultats pour suivre les tests A/B ou les variantes de campagne.

Modèles pris en charge

Tous les modèles utilisent la même surface d'API, avec simplement des identifiants différents.

Authentification en 30 secondes

Générez une clé API depuis le tableau de bord sous Paramètres > Clés API. Envoyez-la en tant que token Bearer :

curl -H "Authorization: Bearer YOUR_API_KEY" \
     https://api.arteza.ai/v1/account/credits

Réponse :

{
  "credits": 2750,
  "tier": "popular"
}

Règles de sécurité essentielles :

• Ne jamais inclure votre clé API dans du code côté client ou dans des dépôts publics
• La stocker dans des variables d'environnement (SEEDANCE_API_KEY)
• Faire tourner les clés régulièrement depuis le tableau de bord
• Chaque clé hérite du solde de crédits de son compte parent

L'endpoint texte vers vidéo

C'est l'endpoint que vous utiliserez le plus.

POST /v1/generate/text-to-video

{
  "model": "seedance-2.0",
  "prompt": "Aerial shot of a coastal city at sunset, golden light reflecting off glass skyscrapers, cinematic drone footage",
  "duration": 10,
  "aspect_ratio": "16:9",
  "audio": true
}

Référence des paramètres

Réponse en cas de succès

{
  "task_id": "task_abc123def456",
  "status": "queued",
  "model": "seedance-2.0",
  "credits_charged": 607,
  "estimated_time": 120,
  "created_at": "2026-04-10T14:30:00Z"
}

La génération est asynchrone. Vous obtenez immédiatement un task_id et vous interrogez l'état jusqu'à la fin du traitement (ou vous utilisez des webhooks).

L'endpoint image vers vidéo

Animez une image source à l'aide d'un prompt de mouvement.

POST /v1/generate/image-to-video
Content-Type: multipart/form-data

Vous préférez ne pas envoyer de fichier ? Passez plutôt une image_url :

{
  "model": "seedance-2.0",
  "image_url": "https://example.com/photo.jpg",
  "prompt": "The woman turns her head slowly and smiles, wind gently blowing her hair",
  "duration": 8,
  "aspect_ratio": "16:9"
}

Vérification du statut de génération

Interrogez l'endpoint de tâche pour vérifier la progression.

GET /v1/tasks/{task_id}

Réponse en cours de traitement

{
  "task_id": "task_abc123def456",
  "status": "processing",
  "progress": 65,
  "model": "seedance-2.0",
  "created_at": "2026-04-10T14:30:00Z",
  "estimated_completion": "2026-04-10T14:31:30Z"
}

Réponse une fois terminé

{
  "task_id": "task_abc123def456",
  "status": "completed",
  "model": "seedance-2.0",
  "result": {
    "video_url": "https://cdn.arteza.ai/outputs/task_abc123def456.mp4",
    "duration": 10,
    "resolution": "1280x720",
    "has_audio": true,
    "file_size": 8542310
  },
  "credits_charged": 607,
  "created_at": "2026-04-10T14:30:00Z",
  "completed_at": "2026-04-10T14:31:28Z"
}

Valeurs de statut

Les URLs de vidéo expirent au bout de 24 heures. Téléchargez-les et stockez-les sur votre propre infrastructure sans tarder.

Vous souhaitez générer ce type de résultat par programmation ? Votre premier appel API est à 30 secondes. Obtenez votre clé API gratuitement →

Exemple Python prêt pour la production

Voici un script complet qui soumet une génération, interroge l'état jusqu'à la fin et télécharge le résultat.

import os
import time
import requests

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}


def generate_video(prompt, duration=8, aspect_ratio="16:9"):
    """Soumet une tâche texte vers vidéo. Retourne le task_id."""
    response = requests.post(
        f"{BASE_URL}/generate/text-to-video",
        headers=HEADERS,
        json={
            "model": "seedance-2.0",
            "prompt": prompt,
            "duration": duration,
            "aspect_ratio": aspect_ratio,
            "audio": True,
        },
    )
    response.raise_for_status()
    return response.json()["task_id"]


def wait_for_completion(task_id, poll_interval=5, timeout=300):
    """Interroge jusqu'à la fin de la tâche. Retourne le dictionnaire de résultat."""
    elapsed = 0
    while elapsed < timeout:
        response = requests.get(f"{BASE_URL}/tasks/{task_id}", headers=HEADERS)
        response.raise_for_status()
        data = response.json()

        if data["status"] == "completed":
            return data["result"]
        if data["status"] == "failed":
            raise RuntimeError(f"Generation failed: {data.get('error')}")

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")


def download_video(video_url, output_path):
    """Télécharge la vidéo en streaming sur le disque."""
    response = requests.get(video_url, stream=True)
    response.raise_for_status()
    with open(output_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)


if __name__ == "__main__":
    task_id = generate_video(
        prompt="A cat sitting on a windowsill watching rain fall outside, cozy indoor lighting, shallow depth of field",
        duration=10,
    )
    print(f"Task submitted: {task_id}")

    result = wait_for_completion(task_id)
    print(f"Video ready: {result['video_url']}")

    download_video(result["video_url"], "output.mp4")
    print("Downloaded to output.mp4")

Exemple JavaScript (Node.js)

Le même workflow en Node.js moderne avec fetch natif.

const API_KEY = process.env.SEEDANCE_API_KEY;
const BASE_URL = "https://api.arteza.ai/v1";

async function generateVideo(prompt, duration = 8, aspectRatio = "16:9") {
  const response = await fetch(`${BASE_URL}/generate/text-to-video`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "seedance-2.0",
      prompt,
      duration,
      aspect_ratio: aspectRatio,
      audio: true,
    }),
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }
  const data = await response.json();
  return data.task_id;
}

async function waitForCompletion(taskId, pollMs = 5000, timeoutMs = 300000) {
  const start = Date.now();

  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${BASE_URL}/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const data = await response.json();

    if (data.status === "completed") return data.result;
    if (data.status === "failed") {
      throw new Error(`Generation failed: ${data.error}`);
    }

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

  throw new Error(`Task ${taskId} timed out`);
}

// Utilisation
const taskId = await generateVideo(
  "Timelapse of a flower blooming, macro lens, soft natural lighting",
  12
);
console.log(`Task submitted: ${taskId}`);

const result = await waitForCompletion(taskId);
console.log(`Video ready: ${result.video_url}`);

Image vers vidéo en Python

Lorsque vous devez envoyer une image source, utilisez multipart/form-data :

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Génère une vidéo à partir d'un fichier image local."""
    with open(image_path, "rb") as img_file:
        response = requests.post(
            f"{BASE_URL}/generate/image-to-video",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"image": img_file},
            data={
                "model": model,
                "prompt": prompt,
                "duration": duration,
                "aspect_ratio": "16:9",
                "audio": "true",
            },
        )
    response.raise_for_status()
    return response.json()["task_id"]

Gestion des erreurs robuste

L'API utilise les codes de statut HTTP standard avec des corps d'erreur structurés.

Format de la réponse d'erreur

{
  "error": {
    "code": "insufficient_credits",
    "message": "Your account has 8 credits but this generation requires 24 credits.",
    "required_credits": 24,
    "available_credits": 8
  }
}

Modèle recommandé

try:
    task_id = generate_video(prompt)
except requests.exceptions.HTTPError as e:
    status = e.response.status_code
    if status == 402:
        error = e.response.json()["error"]
        print(f"Need {error['required_credits']} credits, have {error['available_credits']}")
        # Rediriger l'utilisateur vers /pricing
    elif status == 429:
        retry_after = int(e.response.headers.get("Retry-After", 60))
        print(f"Rate limited. Retry after {retry_after}s.")
    else:
        raise

Limites de débit et bonnes pratiques en production

Les limites

Cinq pratiques essentielles en production

1. Utilisez les webhooks plutôt que l'interrogation à grande échelle. L'interrogation gaspille des appels API. Les webhooks se déclenchent exactement une fois.
2. Implémentez un délai exponentiel sur les réponses 429. Ne réessayez pas immédiatement.
3. Téléchargez les URLs de vidéo rapidement. Elles expirent au bout de 24 heures. Stockez-les sur votre propre CDN.
4. Validez les entrées côté client. Détectez les problèmes de longueur de prompt et de taille de fichier avant d'appeler l'API.
5. Vérifiez le solde de crédits avant les traitements par lots. Une erreur 402 en plein milieu d'un lot est pénible. Interrogez /account/credits en premier.

Intégration des webhooks

Incluez webhook_url dans votre requête de génération et Arteza fera une requête POST vers cette URL lorsque la tâche sera terminée.

{
  "model": "seedance-2.0",
  "prompt": "...",
  "webhook_url": "https://yourapp.com/api/seedance/webhook"
}

Contenu du webhook

{
  "event": "task.completed",
  "task_id": "task_abc123def456",
  "status": "completed",
  "result": {
    "video_url": "https://cdn.arteza.ai/outputs/task_abc123def456.mp4",
    "duration": 10,
    "resolution": "1280x720",
    "has_audio": true
  },
  "metadata": {
    "campaign_id": "summer-2026",
    "variant": "A"
  },
  "timestamp": "2026-04-10T14:31:28Z"
}

Les requêtes webhook incluent un en-tête X-Seedance-Signature, une signature HMAC-SHA256 du corps signée avec votre secret webhook. Vérifiez toujours la signature avant de traiter les événements.

Génération par lots

Lorsque vous avez besoin de plusieurs clips, soumettez-les en lot et recevez un seul webhook une fois tout terminé.

POST /v1/generate/batch

{
  "tasks": [
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scene 1 description...",
      "duration": 8
    },
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scene 2 description...",
      "duration": 10
    },
    {
      "type": "image-to-video",
      "model": "seedance-1.0-pro",
      "image_url": "https://example.com/product.jpg",
      "prompt": "Slow rotation revealing product details",
      "duration": 6
    }
  ],
  "webhook_url": "https://yourapp.com/api/seedance/batch-complete"
}

Les tâches d'un lot sont traitées en parallèle jusqu'à votre limite de concurrence.

Quatre cas d'usage qui méritent d'être développés

1. Vidéos produits e-commerce à grande échelle

Automatisez l'animation de produits pour l'ensemble de votre catalogue. Parcourez votre base de données produits, lancez un appel image vers vidéo par article et stockez les URLs résultantes avec la fiche produit.

products = get_products_from_database()

for product in products:
    task_id = generate_from_image(
        image_path=product["hero_image"],
        prompt=f"Slow 360 rotation of {product['name']}, studio lighting, white background",
        model="seedance-1.0-pro",
        duration=6,
    )
    save_task_mapping(product["id"], task_id)

Combinez ceci avec le guide vidéo pour le e-commerce pour des conseils sur le workflow.

2. Pipelines de réseaux sociaux automatisés

Alimentez des générateurs de prompts avec des sujets tendance, générez chaque jour des vidéos verticales et envoyez-les dans une file de validation :

for topic in get_trending_topics():
    prompt = build_prompt(topic)
    task_id = generate_video(prompt, duration=6, aspect_ratio="9:16")
    queue_for_review(task_id, topic)

3. Tests A/B marketing

Générez plusieurs variantes créatives avec un suivi par métadonnées :

variants = [
    "Product hero shot with warm lighting, luxury feel",
    "Product hero shot with bright lighting, energetic feel",
    "Product hero shot with moody lighting, premium feel",
]

for i, variant in enumerate(variants):
    generate_video(
        prompt=variant,
        duration=6,
        metadata={"variant": chr(65 + i), "campaign": "spring-launch"},
    )

Le champ metadata est renvoyé dans la réponse de fin de traitement, ce qui vous permet d'acheminer automatiquement les résultats vers le bon compartiment de campagne.

4. Applications interactives

Intégrez la génération vidéo directement dans votre propre application. Un utilisateur saisit un prompt, votre backend appelle l'API, le webhook livre le clip terminé. L'ensemble du processus prend environ 90 secondes.

En conclusion

L'API Arteza est simple à intégrer et prête pour la production. Une authentification simple, une sémantique REST propre, des webhooks pour le travail asynchrone et des endpoints de traitement par lots pour passer à l'échelle. Si vous avez déjà utilisé Stripe ou une API REST moderne, vous vous y sentirez à l'aise en dix minutes.

Pour la tarification et l'optimisation des crédits, consultez le guide des tarifs. Pour une vue d'ensemble du produit, lisez le guide complet de Seedance 2.0.

Prêt à commencer à construire ? Créez votre compte gratuit →

À lire également : Guide complet de Seedance 2.0 • Guide des tarifs • Seedance 2.0 vs Seedance 1.0 • Seedance 2.0 vs Runway Gen-4