API OmniHuman v1.5 : Génération vidéo d'avatar par programmation

Exécuter OmniHuman v1.5 via l'interface Arteza est excellent pour les créations ponctuelles. Pour les workflows à haut volume - prospection commerciale personnalisée, lancements multilingues, génération vidéo pilotée par CMS, digests actualités automatisés - vous avez besoin de l'API. Ce guide couvre l'authentification, les endpoints, la structure des requêtes, la gestion des webhooks et les patterns de production. Chaque génération coûte 960 crédits ($9,60) que vous l'invoquez via l'interface ou l'API.

Pourquoi utiliser l'API

L'API déverrouille des patterns d'automatisation que l'interface ne peut pas égaler :

• Génération par lot. Exécutez 100+ vidéos dans une seule exécution de pipeline.
• Personnalisation dynamique. Tirez les données d'un CRM et générez une vidéo par prospect.
• Workflows programmés. Digests actualités quotidiens, vidéos récapitulatives hebdomadaires, mises à jour déclenchées.
• Intégration avec les stacks existantes. Node.js, Python, Go, Ruby - tout langage avec HTTP peut l'appeler.
• Production reproductible. Scripts versionnés plutôt que clics manuels sur l'interface.

Si votre cas d'usage implique plus de 10 vidéos ayant une structure similaire, l'API vaut la peine d'être configurée.

Authentification

Les requêtes API Arteza s'authentifient via une clé API transmise dans l'en-tête Authorization en tant que token Bearer.

Obtenir votre clé API

1. Connectez-vous à arteza.ai
2. Accédez aux paramètres de votre compte
3. Trouvez la section API
4. Générez une nouvelle clé API
5. Stockez-la de manière sécurisée - traitez-la comme un mot de passe

Ne validez jamais votre clé API dans le contrôle de source. Utilisez des variables d'environnement :

export SEEDANCE_API_KEY="your_api_key_here"

En-tête d'authentification

Chaque requête inclut :

Authorization: Bearer YOUR_SEEDANCE_API_KEY
Content-Type: application/json

Structure des endpoints

L'API OmniHuman v1.5 suit les patterns de génération asynchrone standard :

• POST pour créer une tâche de génération
• GET pour interroger le statut et les résultats
• Webhook pour la livraison asynchrone (recommandé pour la production)

URL de base

https://api.arteza.ai/v1

Endpoints clés

Consultez la documentation API Arteza en direct pour les chemins d'endpoints exacts, car ils peuvent évoluer.

Soumettre une tâche de génération

Structure de requête

{
  "model": "omnihuman-v1.5",
  "image_url": "https://example.com/portrait.jpg",
  "audio_url": "https://example.com/speech.mp3",
  "prompt": "Modern corporate office with soft natural lighting, medium close-up framing head and shoulders, professional broadcast style",
  "resolution": "1080p",
  "turbo_mode": false,
  "webhook_url": "https://yourapp.com/webhooks/seedance"
}

Référence des paramètres

Exigences des fichiers d'entrée

Image :

• Formats : JPEG, PNG
• Résolution : 512x512 minimum, 1024x1024+ recommandé
• Accessible via URL HTTPS publique

Audio :

• Formats : MP3, WAV, M4A
• Durée : ≤60s pour 720p, ≤30s pour 1080p
• Accessible via URL HTTPS publique

Si vos fichiers ne sont pas déjà hébergés publiquement, téléchargez-les vers S3, Cloudflare R2, Google Cloud Storage ou similaire avant d'effectuer l'appel API.

Exemple de requête en Python

import os
import requests

SEEDANCE_API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1"

def create_omnihuman_video(image_url, audio_url, prompt,
                           resolution="1080p", turbo=False):
    headers = {
        "Authorization": f"Bearer {SEEDANCE_API_KEY}",
        "Content-Type": "application/json",
    }
    payload = {
        "model": "omnihuman-v1.5",
        "image_url": image_url,
        "audio_url": audio_url,
        "prompt": prompt,
        "resolution": resolution,
        "turbo_mode": turbo,
    }
    response = requests.post(
        f"{BASE_URL}/omnihuman/generate",
        json=payload,
        headers=headers,
    )
    response.raise_for_status()
    return response.json()

job = create_omnihuman_video(
    image_url="https://cdn.example.com/ceo.jpg",
    audio_url="https://cdn.example.com/weekly-update.mp3",
    prompt="Corporate office with warm lighting, medium close-up, professional style",
)
print(f"Job submitted: {job['job_id']}")

Exemple de requête en Node.js

import fetch from "node-fetch";

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

async function createOmnihumanVideo({
  imageUrl,
  audioUrl,
  prompt,
  resolution = "1080p",
  turbo = false,
}) {
  const response = await fetch(`${BASE_URL}/omnihuman/generate`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${SEEDANCE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "omnihuman-v1.5",
      image_url: imageUrl,
      audio_url: audioUrl,
      prompt,
      resolution,
      turbo_mode: turbo,
    }),
  });

  if (!response.ok) {
    throw new Error(`Arteza API error: ${response.status}`);
  }
  return response.json();
}

const job = await createOmnihumanVideo({
  imageUrl: "https://cdn.example.com/ceo.jpg",
  audioUrl: "https://cdn.example.com/update.mp3",
  prompt: "Modern office, soft lighting, medium close-up",
});
console.log(`Job submitted: ${job.job_id}`);

Format de réponse

{
  "job_id": "job_abc123xyz",
  "status": "queued",
  "created_at": "2026-04-10T14:23:00Z",
  "estimated_credits": 960
}

Le job_id est ce que vous utilisez pour interroger ou corréler les livraisons de webhooks.

Interrogation des résultats

Si vous n'utilisez pas de webhooks, interrogez l'endpoint de statut de tâche jusqu'à la complétion.

import time

def wait_for_video(job_id, timeout_seconds=600, poll_interval=5):
    headers = {"Authorization": f"Bearer {SEEDANCE_API_KEY}"}
    deadline = time.time() + timeout_seconds

    while time.time() < deadline:
        response = requests.get(
            f"{BASE_URL}/jobs/{job_id}",
            headers=headers,
        )
        response.raise_for_status()
        data = response.json()
        status = data["status"]

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

        time.sleep(poll_interval)

    raise TimeoutError("Job did not complete within timeout")

video_url = wait_for_video(job["job_id"])
print(f"Video ready: {video_url}")

Valeurs de statut de tâche

Utiliser les webhooks (recommandé pour la production)

Les webhooks éliminent l'interrogation et vous permettent de construire des pipelines pilotés par les événements.

Configuration d'un webhook

Transmettez webhook_url dans votre requête de génération. Seedance envoie un POST à cette URL quand la tâche est complète.

Charge utile du webhook

{
  "event": "job.completed",
  "job_id": "job_abc123xyz",
  "status": "completed",
  "result": {
    "video_url": "https://cdn.arteza.ai/outputs/video_abc123.mp4",
    "resolution": "1080p",
    "duration_seconds": 28.5
  },
  "credits_used": 960,
  "completed_at": "2026-04-10T14:26:45Z"
}

Exemple de gestionnaire de webhook

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/webhooks/seedance", methods=["POST"])
def seedance_webhook():
    payload = request.get_json()

    if payload.get("event") == "job.completed":
        job_id = payload["job_id"]
        video_url = payload["result"]["video_url"]

        # Votre logique métier : télécharger la vidéo, notifier les utilisateurs,
        # déclencher des workflows en aval, etc.
        handle_completed_video(job_id, video_url)

    return jsonify({"received": True}), 200

Sécurité du webhook

Vérifiez les signatures de webhook si Arteza fournit un secret de signature. Validez toujours que les webhooks proviennent d'Arteza avant d'agir sur eux.

Prêt à essayer OmniHuman v1.5 ? Commencer à créer gratuitement →

Voulez-vous un présentateur comme celui-ci ? Essayer OmniHuman gratuitement →

Patterns de production

Pattern 1 : Pipeline de vidéo commerciale personnalisée

Générez une vidéo par prospect avec variables de script dynamiques.

def generate_sales_video_for_prospect(prospect):
    script = render_template("sales_template.txt", {
        "first_name": prospect["first_name"],
        "company": prospect["company"],
        "trigger": prospect["trigger_event"],
    })

    audio_url = generate_tts(script)

    job = create_omnihuman_video(
        image_url=YOUR_SDR_PHOTO_URL,
        audio_url=audio_url,
        prompt=STANDARD_SCENE_PROMPT,
        resolution="1080p",
    )
    return job["job_id"]

prospects = load_prospects_from_crm()
for prospect in prospects:
    generate_sales_video_for_prospect(prospect)

Consultez le guide des vidéos de vente pour l'écriture de scénarios et la distribution.

Pattern 2 : Lancement de contenu multilingue

Générez le même message dans plusieurs langues, même photo.

languages = [
    ("en", "english_audio.mp3"),
    ("es", "spanish_audio.mp3"),
    ("pt", "portuguese_audio.mp3"),
    ("fr", "french_audio.mp3"),
    ("de", "german_audio.mp3"),
]

jobs = []
for lang_code, audio_file in languages:
    audio_url = upload_to_cdn(audio_file)
    job = create_omnihuman_video(
        image_url=SPOKESPERSON_PHOTO_URL,
        audio_url=audio_url,
        prompt=STANDARD_PROMPT,
    )
    jobs.append((lang_code, job["job_id"]))

Consultez le guide multilingue pour les conseils de voix et traduction.

Pattern 3 : Automatisation de digest actualités quotidiens

Pipeline programmé qui récupère les gros titres, génère la synthèse vocale et produit une vidéo quotidienne.

from datetime import datetime

def daily_news_digest():
    headlines = fetch_top_headlines()
    script = format_headlines_as_script(headlines)
    audio_url = generate_tts(script, voice="broadcast_news")

    job = create_omnihuman_video(
        image_url=NEWS_ANCHOR_PHOTO_URL,
        audio_url=audio_url,
        prompt="Professional news studio, broadcast style, medium close-up",
        resolution="720p",
    )
    return job["job_id"]

# Programmez via cron, Airflow ou votre outil de workflow
daily_news_digest()

Consultez le guide présentateur de nouvelles.

Pattern 4 : Génération de vidéo déclenchée par CMS

Quand un nouvel article de blog ou produit est publié, générez une vidéo compagnon.

@app.route("/cms/published", methods=["POST"])
def on_content_published():
    content = request.get_json()
    script = summarize_content(content["body"])
    audio_url = generate_tts(script)

    job = create_omnihuman_video(
        image_url=BRAND_SPOKESPERSON_PHOTO,
        audio_url=audio_url,
        prompt=BRAND_SCENE_PROMPT,
        webhook_url="https://yourapp.com/webhooks/seedance",
    )
    store_job_mapping(content["id"], job["job_id"])
    return {"ok": True}

Bonnes pratiques de gestion d'erreurs

Réessai avec backoff exponentiel

Les erreurs réseau et les défaillances transitoires doivent déclencher des tentatives, pas l'abandon immédiat.

import time

def create_with_retry(params, max_retries=3):
    delay = 2
    for attempt in range(max_retries):
        try:
            return create_omnihuman_video(**params)
        except requests.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(delay)
            delay *= 2

Valider les entrées avant de soumettre

Économisez des crédits en validant avant chaque appel API :

• L'URL de l'image retourne 200 et content-type image/*
• L'URL audio retourne 200 et content-type audio/*
• La durée audio est dans la limite pour la résolution choisie
• Le prompt n'est pas vide

Gérer les limites de débit

L'API applique des limites de débit. Respectez les réponses 429 et reculez de manière appropriée.

Surveiller le solde de crédits

Vérifiez votre solde de crédits avant les gros exécutions par lot. Manquer de crédits en plein lot est évitable.

Gestion des coûts

Chaque vidéo générée par API coûte 960 crédits ($9,60). Le même pack de crédits qui alimente l'interface alimente l'API :

Pour les charges de travail API lourdes, le tier Max vous donne le meilleur coût effectif par génération. Consultez le guide tarifaire pour plus de détails.

Estimation du coût du projet

Avant de démarrer une exécution par lot, calculez le coût total :

total_cost = number_of_videos * 9.60

Un lot de 1 000 vidéos : $9 600 au tarif de base, ~$8 000 sur le tier Max. Budgétisez en conséquence.

Observabilité

Pour les workflows de production, suivez ces métriques :

• Taux de succès - % de tâches qui se complètent avec succès
• Temps de génération moyen - pour la planification des capacités
• Crédits consommés - totaux cumulés pour le suivi du budget
• Taux de livraison des webhooks - détecter les défaillances de livraison de webhook
• Catégorisation des erreurs - regrouper les défaillances par cause

Enregistrez les ID de tâche aux côtés de vos ID de corrélation internes pour le débogage.

Bonnes pratiques de sécurité

• Ne jamais exposer votre clé API côté client. Appelez toujours l'API depuis votre backend.
• Utilisez des variables d'environnement ou un gestionnaire de secrets. Ne validez jamais les clés dans le contrôle de source.
• Tournez les clés périodiquement. Traitez-les comme tout autre identifiant.
• Validez les signatures des webhooks quand disponible.
• Utilisez HTTPS pour toutes les URLs d'image et audio que vous transmettez à l'API.
• Étendez les endpoints des webhooks pour que seules les charges utiles Arteza légitimes soient traitées.

Débuter avec l'API

1. S'inscrire à Arteza et collectez vos 50 crédits gratuits
2. Achetez au moins un pack Starter ($10) pour avoir assez pour une génération de test
3. Générez votre clé API dans le tableau de bord
4. Préparez un fichier image et audio de test, téléchargez vers une URL publique
5. Effectuez votre premier appel API en utilisant les exemples ci-dessus
6. Interrogez ou attendez le webhook pour récupérer l'URL de la vidéo
7. Construisez votre pipeline de production

Pour des lectures associées, consultez le guide complet d'OmniHuman v1.5, détail des tarifs, guide des vidéos de vente, et guide multilingue.

Prêt à essayer OmniHuman v1.5 ? Commencer à créer gratuitement →