API Seedance 1.0 Pro : endpoint de génération vidéo professionnelle

Si vous intégrez la vidéo dans un produit, un workflow ou un pipeline, l'interface web finit toujours par devenir un goulot d'étranglement. L'API Seedance 1.0 Pro repose sur le même modèle que l'interface, exposé sous la forme d'un endpoint REST propre avec une authentification par bearer token, une tarification prévisible à la seconde et un polling de tâches simple. Ce guide couvre tout ce dont vous avez besoin pour le déployer en production.

En bref

• API REST pour la génération vidéo native 1080p avec Seedance 1.0 Pro
• Auth : bearer token depuis votre tableau de bord du compte
• Facturation : à la seconde, environ $0,12/sec, arrondie au crédit entier supérieur
• Principe : soumettre la tâche → vérifier le statut → télécharger le MP4
• Idéal pour : intégrations SaaS, pipelines de traitement par lots, automatisation, produits en marque blanche

Ce que l'API vous offre

Toutes les fonctionnalités de l'interface web Seedance 1.0 Pro, accessibles par programmation :

• Génération image-vers-vidéo à partir d'une URL d'image source
• Prompt de mouvement pour diriger l'animation
• Contrôle de la durée de 2 à 12 secondes
• Contrôle de l'image de fin pour des transitions guidées
• Verrouillage de caméra activable ou désactivable
• Polling de tâche pour le statut et l'URL du résultat
• Sortie MP4 en 1080p natif

Utilisez-le pour des produits SaaS nécessitant une génération vidéo intégrée, des pipelines d'agence internes, des workflows de production en série ou l'automatisation de tâches vidéo répétitives.

Authentification

Tous les appels API s'authentifient avec un bearer token. Générez-en un depuis le tableau de bord de votre compte Arteza sur arteza.ai.

Authorization: Bearer YOUR_API_KEY

Règles de sécurité :

• Ne jamais committer les clés API dans le contrôle de version
• Faire tourner les clés régulièrement
• Utiliser des variables d'environnement ou un gestionnaire de secrets
• Restreindre les clés à des origines spécifiques si possible

Les endpoints principaux

Soumettre une tâche de génération

POST /v1/seedance-1-pro/generate

Corps de la requête :

{
  "source_image_url": "https://your-cdn.com/source.jpg",
  "prompt": "Slow camera push-in on the subject, warm golden hour light, shallow depth of field",
  "duration_seconds": 6,
  "camera_lock": false,
  "end_frame_url": null
}

Paramètres :

Réponse :

{
  "job_id": "job_abc123xyz",
  "status": "queued",
  "created_at": "2026-04-10T12:00:00Z",
  "estimated_seconds": 90
}

Vérifier le statut d'une tâche

GET /v1/seedance-1-pro/status/{job_id}

Réponse (en cours) :

{
  "job_id": "job_abc123xyz",
  "status": "processing",
  "progress": 0.45,
  "created_at": "2026-04-10T12:00:00Z"
}

Réponse (terminé) :

{
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "resolution": "1920x1080",
  "credits_charged": 144
}

Valeurs de statut possibles : queued, processing, completed, failed

Télécharger le résultat

Une fois le statut completed, le champ video_url pointe vers un fichier MP4 1080p. Téléchargez-le immédiatement et stockez-le dans votre propre infrastructure : ne comptez pas sur la validité indéfinie de l'URL.

Exemple complet en Python

import os
import time
import requests

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1/seedance-1-pro"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def generate_video(source_image_url, prompt, duration=6, camera_lock=False, end_frame=None):
    payload = {
        "source_image_url": source_image_url,
        "prompt": prompt,
        "duration_seconds": duration,
        "camera_lock": camera_lock,
    }
    if end_frame:
        payload["end_frame_url"] = end_frame
    
    response = requests.post(f"{BASE_URL}/generate", headers=HEADERS, json=payload)
    response.raise_for_status()
    return response.json()["job_id"]

def wait_for_completion(job_id, poll_interval=5, timeout=300):
    start = time.time()
    while time.time() - start < timeout:
        r = requests.get(f"{BASE_URL}/status/{job_id}", headers=HEADERS)
        r.raise_for_status()
        data = r.json()
        
        if data["status"] == "completed":
            return data["video_url"]
        if data["status"] == "failed":
            raise RuntimeError(f"Tâche échouée : {data.get('error', 'inconnu')}")
        
        time.sleep(poll_interval)
    
    raise TimeoutError(f"La tâche {job_id} n'a pas abouti dans le délai imparti de {timeout}s")

def download_video(url, output_path):
    response = requests.get(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)

# Utilisation
job_id = generate_video(
    source_image_url="https://example.com/product.jpg",
    prompt="Slow camera orbit around the product, studio lighting, 6 seconds",
    duration=6,
    camera_lock=True
)

video_url = wait_for_completion(job_id)
download_video(video_url, "output.mp4")
print(f"Vidéo enregistrée dans output.mp4")

Exemple complet en Node.js

import fs from 'fs';
import fetch from 'node-fetch';

const API_KEY = process.env.SEEDANCE_API_KEY;
const BASE_URL = 'https://api.arteza.ai/v1/seedance-1-pro';
const HEADERS = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

async function generateVideo(opts) {
  const response = await fetch(`${BASE_URL}/generate`, {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(opts)
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  const data = await response.json();
  return data.job_id;
}

async function waitForCompletion(jobId, { pollInterval = 5000, timeout = 300000 } = {}) {
  const start = Date.now();
  while (Date.now() - start < timeout) {
    const r = await fetch(`${BASE_URL}/status/${jobId}`, { headers: HEADERS });
    const data = await r.json();
    if (data.status === 'completed') return data.video_url;
    if (data.status === 'failed') throw new Error(`Tâche échouée : ${data.error}`);
    await new Promise(res => setTimeout(res, pollInterval));
  }
  throw new Error('Délai dépassé');
}

async function downloadVideo(url, path) {
  const response = await fetch(url);
  const buffer = await response.buffer();
  fs.writeFileSync(path, buffer);
}

// Utilisation
const jobId = await generateVideo({
  source_image_url: 'https://example.com/product.jpg',
  prompt: 'Slow camera orbit around the product, studio lighting, 6 seconds',
  duration_seconds: 6,
  camera_lock: true
});

const videoUrl = await waitForCompletion(jobId);
await downloadVideo(videoUrl, 'output.mp4');
console.log('Fichier output.mp4 enregistré');

Vous voulez une qualité de diffusion comme celle-ci ? Essayez Seedance 1.0 Pro gratuitement →

Tarification et facturation

Tarif : environ $0,12 par seconde de vidéo générée, arrondi au crédit entier supérieur

Les crédits sont débités uniquement en cas de génération réussie. Les tâches échouées ne consomment pas de crédits.

Les abonnements sont identiques à ceux de l'interface web : $5 Starter, $25 Creator, $50 Pro, $120 Studio. Consultez les page de tarification.

Limites de débit et concurrence

Les comptes standard disposent de limites de débit adaptées aux charges d'intégration habituelles. Pour une production à fort volume, contactez le support pour obtenir des limites relevées.

Recommandations générales :

• 5 à 10 tâches simultanées est fiable pour la plupart des comptes
• Backoff exponentiel sur les réponses HTTP 429
• Nouvelles tentatives au niveau de la tâche en cas d'erreurs transitoires (jusqu'à 3 essais)
• Callbacks webhook disponibles pour éviter un polling excessif

Webhooks (facultatif)

Plutôt que de faire du polling, enregistrez une URL webhook dans les paramètres de votre compte ou par requête. Lorsqu'une tâche est terminée, Arteza envoie un POST à votre URL :

{
  "event": "job.completed",
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "credits_charged": 144,
  "timestamp": "2026-04-10T12:02:15Z"
}

Les webhooks sont signés avec une signature HMAC dans l'en-tête X-Seedance-Signature. Vérifiez-la avant de faire confiance au contenu.

Gestion des erreurs

L'API retourne des codes de statut HTTP standard :

Les corps de réponse en cas d'erreur incluent un champ error avec un message lisible et un champ code pour la gestion programmatique.

{
  "error": "Source image URL could not be fetched",
  "code": "source_image_unreachable"
}

Exigences relatives à l'image source

• Formats : PNG, JPEG, WebP
• Taille : jusqu'à 10 Mo par image
• Résolution : 512x512 minimum, plus élevée est mieux (1080p+ recommandé)
• Accès à l'URL : doit être accessible publiquement par les serveurs Arteza (pas de localhost, pas d'URL protégée par authentification)

Pour les images privées, téléversez-les sur une URL S3 signée, CloudFront ou un service similaire, et passez l'URL signée dans la requête.

Bonnes pratiques

1. Stockez les sorties dans votre propre infrastructure. Ne comptez pas sur les URL Arteza sur le long terme.
2. Journalisez tout. Identifiants de tâche, prompts, durées, transitions de statut, erreurs.
3. Réessayez les erreurs transitoires. Les problèmes réseau et les réponses 5xx doivent être relancés avec un backoff exponentiel.
4. Validez les entrées en amont. Vérifiez les URL d'images et les plages de paramètres avant de soumettre.
5. Surveillez le solde de crédits. Déclenchez une alerte quand vous descendez sous un seuil.
6. Utilisez les webhooks en production. Le polling convient pour de petites charges, mais devient inefficace à grande échelle.
7. Mettez en cache les générations identiques. Si un utilisateur soumet la même image et le même prompt deux fois, renvoyez l'URL en cache.

Tests et environnement de staging

Commencez chaque intégration avec le plan Starter à $5 (60 crédits par mois). C'est suffisant pour vingt générations de test de 2 secondes. Construisez et testez votre intégration de bout en bout avant de passer à un plan à plus fort volume.

Cas d'usage

• Plateformes SaaS : permettez à vos utilisateurs de générer des vidéos à partir de leurs propres assets
• E-commerce : générez des vidéos produit animées à partir des visuels du catalogue
• Immobilier : automatisez la production de vidéos d'annonces à partir de photos
• Automatisation marketing : vidéo personnalisée à grande échelle
• Plateformes de contenu : enrichissez articles, annonces ou publications sociales avec de la vidéo générée
• Outils vidéo en marque blanche : construisez votre propre produit vidéo IA sur le backend Arteza

Pour aller plus loin

• Flux de travail par traitement par lots
• Guide complet de Seedance 1.0 Pro
• Seedance 1.0 Pro pour les agences
• Guide de l'API Seedance 2.0

FAQ

Puis-je utiliser l'API pour des applications commerciales ? Oui, toutes les sorties sont autorisées pour un usage commercial.

Que se passe-t-il si la génération échoue ? Aucun crédit n'est débité en cas d'échec de génération.

Combien de temps les vidéos générées sont-elles hébergées ? Les vidéos sont disponibles au téléchargement pendant une fenêtre de temps après la génération. Téléchargez-les et stockez-les rapidement.

Proposez-vous des bibliothèques SDK ? Des SDK communautaires pour Python et Node sont disponibles. Consultez la documentation développeur sur arteza.ai.

Puis-je annuler une tâche en cours ? Oui, envoyez DELETE /v1/seedance-1-pro/jobs/{job_id}. Les crédits ne sont pas débités pour les tâches annulées.

Comment obtenir de l'aide ? Contactez le support par e-mail depuis votre tableau de bord de compte pour les problèmes liés à l'API.

---

L'API Seedance 1.0 Pro est la voie production-ready pour intégrer la génération vidéo IA 1080p dans votre produit ou pipeline.

Obtenez votre clé API et commencez à créer → avec 10 crédits gratuits inclus à l'inscription.