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

Générez une vidéo cinématographique avec l'IA en une seule requête HTTP. L'API Seedance 2.0 utilise le même pipeline de génération que la plateforme web, exposé sous forme d'une interface REST propre avec authentification Bearer, webhooks et endpoints batch. Si vous pouvez effectuer une requête POST, vous pouvez créer un pipeline de génération vidéo.

Ce guide couvre tout ce que vous devez savoir 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.

Résumé : API en un coup d'œil

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

Ce que l'API peut vraiment faire

Tout ce que l'interface web fait, l'API le fait aussi. Texte vers vidéo, image vers vidéo, sélection de modèle, contrôle de la durée, rapport d'aspect, bascules audio et accès à chaque modèle de la plateforme. Endpoints batch pour générer plusieurs clips à la fois. Notifications webhook afin que vous n'ayez pas besoin d'interroger. Métadonnées personnalisées qui sont renvoyées dans les résultats pour le suivi des tests A/B ou des variantes de campagne.

Modèles supportés

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

Authentification en 30 secondes

Générez une clé API depuis le tableau de bord dans 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é qui comptent :

• Ne livrez jamais votre clé API dans du code côté client ou des repos publics
• Stockez-la dans des variables d'environnement (SEEDANCE_API_KEY)
• Rotation les clés périodiquement depuis le tableau de bord
• Chaque clé hérite du solde de crédits de son compte parent

L'endpoint texte vers vidéo

Cet endpoint est celui 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 réussie

{
  "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 la finalisation (ou utilisez des webhooks).

L'endpoint image vers vidéo

Animez une image source avec une invite de mouvement.

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

Préférez ne pas télécharger un 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 terminée

{
  "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 vidéo expirent en 24 heures. Téléchargez-les et stockez-les sur votre propre infrastructure rapidement.

Vous voulez générer des résultats comme celui-ci par programmation ? Vous êtes à 30 secondes de votre premier appel API. Obtenez votre clé API gratuitement →

Exemple Python prêt pour la production

Voici un script complet qui soumet une génération, interroge la finalisation 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"):
    """Submit a text-to-video task. Returns 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):
    """Poll until the task finishes. Returns result dict."""
    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):
    """Stream the video to disk."""
    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`);
}

// Usage
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

Quand vous devez télécharger une image source, utilisez multipart/form-data :

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Generate video from a local image file."""
    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 qui ne s'effondre pas

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

Forme de réponse d'erreur

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

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']}")
        # Redirect the user to /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 meilleures pratiques pour la production

Les limites

Cinq pratiques qui importent en production

1. Utilisez les webhooks, pas l'interrogation, à grande échelle. L'interrogation gaspille les appels API. Les webhooks se déclenchent exactement une fois.
2. Implémentez un backoff exponentiel sur les réponses 429. Ne relancez pas immédiatement.
3. Téléchargez les URLs vidéo rapidement. Elles expirent en 24 heures. Stockez-les sur votre propre CDN.
4. Validez les entrées côté client. Capturez les problèmes de longueur de prompt et de taille de fichier avant de frapper l'API.
5. Vérifiez le solde de crédits avant les tâches batch. Un 402 au milieu d'un batch est ennuyeux. Interrogez /account/credits d'abord.

Intégration Webhook

Incluez webhook_url dans votre demande de génération et Arteza la POSTera quand la tâche se termine.

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

Charge utile 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 demandes de 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 Batch

Quand vous avez besoin de plusieurs clips, soumettez-les en tant que batch et obtenez un webhook quand tout se termine.

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 dans un batch se traitent en concurrence jusqu'à votre limite de concurrence.

Quatre cas d'usage qui valent la peine de construire

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

Automatisez l'animation des produits pour votre catalogue entier. Bouclé sur votre base de données de produits, déclenchez un appel image vers vidéo par article, stockez les URLs résultantes à côté du dossier du 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)

Associez ceci avec le guide vidéo e-commerce pour des conseils de workflow.

2. Pipelines de médias sociaux automatisés

Alimentez les sujets tendance dans les générateurs de prompts, générez la vidéo verticale quotidienne, poussez vers une file d'attente d'examen :

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 du marketing

Générez plusieurs variantes créatives avec suivi des 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 charge utile de finalisation, afin que vous puissiez router automatiquement les résultats vers le bon bucket de campagne.

4. Applications interactives

Construisez la génération vidéo directement dans votre propre app. Un utilisateur tape un prompt, votre backend appelle l'API, le webhook remet le clip terminé. Toute la boucle prend ~90 secondes.

La conclusion

L'API Arteza est simple à intégrer et prête pour la production. Authentification simple, sémantique REST propre, webhooks pour le travail asynchrone et endpoints batch pour la mise à l'échelle. Si vous avez utilisé Stripe ou n'importe quelle API REST moderne, vous vous sentirez à l'aise en dix minutes.

Pour la tarification et l'optimisation des crédits, consultez le guide de tarification. Pour l'aperçu du produit plus large, lisez le guide complet Seedance 2.0.

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

Continuez la lecture : Guide complet Seedance 2.0 • Guide de tarification • Seedance 2.0 vs Seedance 1.0 • Seedance 2.0 vs Runway Gen-4