API OmniHuman v1.5 : génération programmatique de vidéos d'avatars

Utiliser OmniHuman v1.5 via l'interface Arteza est idéal pour une création ponctuelle. Pour les flux de travail à grand volume, comme la prospection commerciale personnalisée, les déploiements multilingues, la génération de vidéos pilotée par un CMS ou les digests d'actualités automatisés, l'API est la bonne solution. Ce guide couvre l'authentification, les points de terminaison, la structure des requêtes, la gestion des webhooks et les schémas de production. Chaque génération coûte 3-72 crédits ($0,30-$7,20), que vous passiez par l'interface ou par l'API.

En résumé

• Générez des vidéos OmniHuman v1.5 par programmation via l'API REST Arteza
• Même tarif $0,30-$7,20 par génération que l'interface, sans surcoût API
• Génération asynchrone avec récupération des résultats par webhook ou par interrogation
• Idéal pour les vidéos de prospection personnalisées, les bibliothèques de formation automatisées et les déploiements multilingues
• Authentification via clé API depuis votre tableau de bord Arteza

Pourquoi utiliser l'API

L'API ouvre des possibilités d'automatisation que l'interface ne peut pas égaler :

• Génération en lot. Exécutez plus de 100 vidéos en une seule passe de pipeline.
• Personnalisation dynamique. Extrayez des données d'un CRM et générez une vidéo par prospect.
• Flux planifiés. Digests d'actualités quotidiens, vidéos de synthèse hebdomadaires, mises à jour déclenchées automatiquement.
• Intégration aux stacks existantes. Node.js, Python, Go, Ruby : tout langage capable d'envoyer des requêtes HTTP peut l'utiliser.
• Production reproductible. Scripts versionnés plutôt que clics manuels dans l'interface.

Si votre cas d'usage implique plus de 10 vidéos à structure similaire, la mise en place de l'API en vaut la peine.

Authentification

Les requêtes à l'API Arteza s'authentifient via une clé API transmise dans l'en-tête Authorization sous forme de jeton Bearer.

Obtenir votre clé API

1. Connectez-vous sur arteza.ai
2. Accédez aux paramètres de votre compte
3. Repérez la section API
4. Générez une nouvelle clé API
5. Conservez-la en lieu sûr : traitez-la comme un mot de passe

Ne commitez jamais votre clé API dans un système de contrôle de version. Utilisez des variables d'environnement :

export SEEDANCE_API_KEY="your_api_key_here"

En-tête d'authentification

Chaque requête doit inclure :

Authorization: Bearer YOUR_SEEDANCE_API_KEY
Content-Type: application/json

Structure des points de terminaison

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

• POST pour créer un job de génération
• GET pour interroger le statut et récupérer les résultats
• Webhook pour une livraison asynchrone (recommandé en production)

URL de base

https://api.arteza.ai/v1

Points de terminaison principaux

Consultez la documentation en ligne de l'API Arteza pour les chemins exacts, car ils peuvent évoluer.

Soumettre un job de génération

Structure de la 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 relatives aux fichiers d'entrée

Image :

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

Audio :

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

Si vos fichiers ne sont pas encore hébergés publiquement, téléversez-les sur S3, Cloudflare R2, Google Cloud Storage ou un service 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 soumis : {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(`Erreur API Arteza : ${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 soumis : ${job.job_id}`);

Format de la réponse

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

Le job_id est utilisé pour interroger le statut ou corréler les livraisons de webhook.

Interrogation des résultats

Si vous n'utilisez pas les webhooks, interrogez le point de terminaison de statut du job jusqu'à ce qu'il soit terminé.

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"Génération échouée : {data.get('error')}")

        time.sleep(poll_interval)

    raise TimeoutError("Le job n'a pas abouti dans le délai imparti")

video_url = wait_for_video(job["job_id"])
print(f"Vidéo prête : {video_url}")

Valeurs de statut d'un job

Utiliser les webhooks (recommandé en production)

Les webhooks éliminent la nécessité d'interroger l'API et permettent de construire des pipelines orientés événements.

Configurer un webhook

Indiquez webhook_url dans votre requête de génération. Seedance effectue un POST vers cette URL dès que le job est terminé.

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": 46,
  "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é des webhooks

Vérifiez les signatures des webhooks si Arteza fournit un secret de signature. Validez toujours que les webhooks proviennent bien d'Arteza avant d'agir sur leur contenu.

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

Vous souhaitez un présentateur comme celui-ci ? Essayer OmniHuman gratuitement →

Schémas de production

Schéma 1 : pipeline de vidéos de prospection personnalisées

Générez une vidéo par prospect avec des 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 guide pour les vidéos de vente pour les conseils sur les scripts et la distribution.

Schéma 2 : déploiement de contenu multilingue

Générez le même message dans plusieurs langues avec la 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 guide multilingue pour les conseils sur la voix et la traduction.

Schéma 3 : automatisation du digest d'actualités quotidien

Pipeline planifié qui récupère les titres, génère un audio TTS 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"]

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

Consultez guide pour les présentateurs de journaux télévisés.

Schéma 4 : génération de vidéos déclenchée par un CMS

À la publication d'un nouvel article de blog ou d'un produit, générez automatiquement une vidéo d'accompagnement.

@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 des erreurs

Nouvelle tentative avec délai exponentiel

Les erreurs réseau et les pannes transitoires doivent déclencher des nouvelles tentatives, pas un 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 la soumission

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

• L'URL de l'image renvoie un code 200 et un content-type image/*
• L'URL de l'audio renvoie un code 200 et un content-type audio/*
• La durée de l'audio respecte 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 grandes exécutions par lots. Épuiser ses crédits en cours de traitement est évitable.

Gestion des coûts

Une vidéo générée via l'API coûte 2,4 crédits par seconde d'audio, soit 72 crédits (7,20 dollars) pour 30 secondes. Les mêmes crédits alimentent l'interface et l'API :

Pour des charges API importantes, l'offre Studio offre le meilleur coût effectif par génération. Consultez guide des tarifs pour plus de détails.

Estimer le coût d'un projet

Avant de lancer un traitement par lot, calculez le coût total :

total_cost = number_of_videos * 4.60

Un lot de 1 000 vidéos de 30 secondes représente 7 200 dollars au tarif de base, et bien moins avec un abonnement mensuel. Budgétisez en conséquence.

Observabilité

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

• Taux de succès : pourcentage de jobs qui se terminent avec succès
• Temps de génération moyen : pour la planification des capacités
• Crédits consommés : totaux glissants pour le suivi budgétaire
• Taux de livraison des webhooks : détectez les échecs de livraison
• Catégorisation des erreurs : regroupez les échecs par cause

Enregistrez les identifiants de job avec vos identifiants de corrélation internes pour faciliter le débogage.

Bonnes pratiques de sécurité

• N'exposez jamais votre clé API côté client. Appelez toujours l'API depuis votre backend.
• Utilisez des variables d'environnement ou un gestionnaire de secrets. Ne commitez jamais de clés dans le contrôle de version.
• Faites pivoter les clés régulièrement. Traitez-les comme n'importe quel autre identifiant.
• Vérifiez les signatures des webhooks lorsqu'elles sont disponibles.
• Utilisez HTTPS pour toutes les URL d'image et d'audio que vous transmettez à l'API.
• Limitez la portée des points de terminaison webhook afin que seules les charges utiles légitimes d'Arteza soient traitées.

Premiers pas avec l'API

1. S'inscrire sur Arteza et récupérez vos 10 crédits offerts
2. Souscrivez au moins à l'offre Starter (5 dollars par mois) pour disposer de suffisamment de crédits pour un test
3. Générez votre clé API dans le tableau de bord
4. Préparez une image et un fichier audio de test, puis téléversez-les vers une URL publique
5. Effectuez votre premier appel API en vous aidant des exemples ci-dessus
6. Interrogez l'API ou attendez le webhook pour récupérer l'URL de la vidéo
7. Construisez votre pipeline de production

Pour des lectures complémentaires, consultez guide complet d'OmniHuman v1.5, détail des tarifs, guide pour les vidéos de vente et guide multilingue.

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