OmniHuman v1.5 API: Programmatyczne generowanie wideo awatarów

Uruchamianie OmniHuman v1.5 przez interfejs Arteza jest świetne do jednorazowych tworzenia. W przypadku przepływów pracy o dużej objętości - spersonalizowana zagraniczna działalność handlowa, wdrożenia wielojęzyczne, generowanie wideo oparte na CMS, zautomatyzowane streszczenia wiadomości - chcesz korzystać z API. Ten przewodnik omawia uwierzytelnianie, punkty końcowe, strukturę żądań, obsługę webhooków i wzorce produkcyjne. Każda generacja kosztuje tyle samo 960 kredytów ($9.60), niezależnie od tego, czy wywołasz ją za pośrednictwem interfejsu użytkownika, czy API.

Dlaczego warto korzystać z API

API odblokowuje wzorce automatyzacji, których interfejs użytkownika nie może dopasować:

• Generowanie partii. Uruchom 100+ filmów w jednym uruchomieniu potoku.
• Dynamiczna personalizacja. Pobierz dane z CRM i wygeneruj film dla każdego potencjalnego klienta.
• Zaplanowane przepływy pracy. Codzienne streszczenia wiadomości, cotygodniowe filmy podsumowujące, wyzwalane aktualizacje.
• Integracja z istniejącymi stosami. Node.js, Python, Go, Ruby - każdy język z HTTP może go wywołać.
• Powtarzalna produkcja. Skrypty kontrolowane wersją zamiast ręcznych kliknięć w interfejsie użytkownika.

Jeśli twój przypadek użycia obejmuje więcej niż 10 filmów o podobnej strukturze, warto skonfigurować API.

Uwierzytelnianie

Żądania API Arteza uwierzytelniają się za pośrednictwem klucza API przekazywanego w nagłówku Authorization jako token nośnika.

Pobieranie klucza API

1. Zaloguj się w arteza.ai
2. Przejdź do ustawień konta
3. Znajdź sekcję API
4. Wygeneruj nowy klucz API
5. Przechowuj bezpiecznie - traktuj go jak hasło

Nigdy nie zatwierdzaj klucza API w kontroli źródła. Użyj zmiennych środowiskowych:

export SEEDANCE_API_KEY="your_api_key_here"

Nagłówek uwierzytelniania

Każde żądanie zawiera:

Authorization: Bearer YOUR_SEEDANCE_API_KEY
Content-Type: application/json

Struktura punktu końcowego

API OmniHuman v1.5 podąża za standardowymi asynchronicznymi wzorcami generowania:

• POST aby utworzyć zadanie generowania
• GET aby sondować status i wyniki
• Webhook dla asynchronicznego dostarczania (zalecane dla produkcji)

Adres URL podstawowy

https://api.arteza.ai/v1

Kluczowe punkty końcowe

Zapoznaj się z aktualną dokumentacją interfejsu API Arteza, aby uzyskać dokładne ścieżki punktów końcowych, ponieważ mogą się zmienić.

Przesyłanie zadania generowania

Struktura żądania

{
  "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"
}

Odwołanie parametru

Wymagania pliku wejściowego

Obraz:

• Formaty: JPEG, PNG
• Rozdzielczość: 512x512 minimum, 1024x1024+ zalecane
• Dostępne za pośrednictwem publicznego adresu URL HTTPS

Audio:

• Formaty: MP3, WAV, M4A
• Czas trwania: ≤60s dla 720p, ≤30s dla 1080p
• Dostępne za pośrednictwem publicznego adresu URL HTTPS

Jeśli Twoje pliki nie są już hostowane publicznie, przesyłaj je do S3, Cloudflare R2, Google Cloud Storage lub podobnie przed wykonaniem wywołania API.

Przykładowe żądanie w Pythonie

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']}")

Przykładowe żądanie w 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 odpowiedzi

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

job_id to to, czego używasz do sondowania lub skorelowania dostarczania webhooku.

Sondowanie wyników

Jeśli nie używasz webhooków, sonduj punkt końcowy stanu zadania, aż zadanie się zakończy.

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}")

Wartości stanu zadania

Korzystanie z webhooków (zalecane dla produkcji)

Webhooks eliminują sondowanie i pozwalają budować asynchroniczne potoki oparte na zdarzeniach.

Konfigurowanie webhooku

Przekaż webhook_url w żądaniu generowania. Seedance wysyła POST na ten adres URL po zakończeniu zadania.

Ładunek webhooku

{
  "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"
}

Przykład obsługi webhooku

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"]

        # Your business logic: download video, notify users,
        # trigger downstream workflows, etc.
        handle_completed_video(job_id, video_url)

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

Bezpieczeństwo webhooku

Zweryfikuj podpisy webhooku, jeśli Arteza udostępnia tajny klucz podpisywania. Zawsze sprawdzaj, czy webhooks pochodzą z Arteza przed podjęciem działania.

Gotowy do spróbowania OmniHuman v1.5? Zacznij tworzyć za darmo →

Chcesz prezentera takiego jak ten? Wypróbuj OmniHuman za darmo →

Wzorce produkcyjne

Wzór 1: Spersonalizowany potok wideo sprzedażowego

Wygeneruj jeden film na potencjalnego klienta z dynamicznymi zmiennymi skryptów.

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)

Zapoznaj się z przewodnik po filmach sprzedażowych, aby uzyskać wskazówki dotyczące skryptów i dystrybucji.

Wzór 2: Wdrożenie zawartości wielojęzycznej

Wygeneruj tę samą wiadomość w wielu językach, to samo zdjęcie.

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"]))

Zapoznaj się z przewodnik wielojęzyczny, aby uzyskać wskazówki dotyczące głosu i tłumaczenia.

Wzór 3: Automatyzacja codziennego streszczenia wiadomości

Zaplanowany potok, który pobiera nagłówki, generuje TTS i tworzy codzienny film.

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"]

# Schedule via cron, Airflow, or your workflow tool
daily_news_digest()

Zapoznaj się z przewodnik po wiadomościach.

Wzór 4: Generowanie wideo wyzwalane przez CMS

Gdy nowy wpis na blogu lub produkt zostanie opublikowany, wygeneruj wideo towarzyszące.

@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}

Najlepsze praktyki obsługi błędów

Ponów próbę z wykładniczym wycofaniem

Błędy sieciowe i przejściowe awarie powinny wyzwolić ponowne próby, a nie natychmiastowe porzucenie.

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

Sprawdzaj dane wejściowe przed przesłaniem

Zaoszczędź kredyty, walidując przed każdym wywołaniem API:

• Adres URL obrazu zwraca 200 i typ zawartości image/*
• Adres URL audio zwraca 200 i typ zawartości audio/*
• Czas trwania audio mieści się w limicie wybranej rozdzielczości
• Monit nie jest pusty

Obsługa limitów szybkości

API wymusza limity szybkości. Szanuj odpowiedzi 429 i odpowiednio się wycofaj.

Monitoruj saldo kredytów

Sprawdź saldo kredytów przed dużymi przebiegami partii. Wyczerpanie kredytów w środku partii jest do uniknięcia.

Zarządzanie kosztami

Każde generowane wideo API kosztuje 960 kredytów ($9.60). Ten sam pakiet kredytów, który napędza interfejs użytkownika, napędza API:

W przypadku dużych obciążeń API poziom Max daje Ci najlepszy efektywny koszt za generację. Zapoznaj się z przewodnik cenowy, aby uzyskać szczegóły.

Szacowanie kosztu projektu

Przed rozpoczęciem przebiegu partii oblicz całkowity koszt:

total_cost = number_of_videos * 9.60

Partia 1000 filmów: $9,600 cena podstawowa, ~$8,000 na poziomie Max. Odpowiednio zaplanuj budżet.

Obserwowność

W przypadku przepływów pracy produkcyjnych śledź te metryki:

• Współczynnik sukcesu - % zadań, które zostały pomyślnie ukończone
• Średni czas generowania - do planowania pojemności
• Zużyte kredyty - bieżące sumy dla śledzenia budżetu
• Częstość dostarczania webhooku - wykryj błędy dostarczania webhooku
• Kategoryzacja błędów - pogrupuj awarie według przyczyny

Rejestruj ID zadań obok wewnętrznych ID korelacji do debugowania.

Najlepsze praktyki bezpieczeństwa

• Nigdy nie odsłaniaj swojego klucza API po stronie klienta. Zawsze wywoływaj API z backendzie.
• Użyj zmiennych środowiskowych lub menedżera tajemnic. Nigdy nie zatwierdzaj kluczy w kontroli źródła.
• Obracaj kluczami okresowo. Traktuj je jak każde inne poświadczenie.
• Zweryfikuj podpisy webhooku, gdy są dostępne.
• Użyj HTTPS dla wszystkich adresów URL obrazu i audio, które przekazujesz do API.
• Ogranicź zakresy punktów końcowych webhooku, aby tylko wiarygodne ładunki Arteza były przetwarzane.

Wprowadzenie do API

1. Zarejestruj się w Arteza i zbierz 50 darmowych kredytów
2. Zakup co najmniej pakiet Starter ($10), aby mieć wystarczająco na testową generację
3. Wygeneruj swój klucz API na pulpicie nawigacyjnym
4. Przygotuj testowy obraz i plik audio, prześlij na publiczny adres URL
5. Wykonaj swoje pierwsze wywołanie API, korzystając z powyższych przykładów
6. Sonduj lub czekaj na webhook, aby pobrać adres URL wideo
7. Zbuduj swój potok produkcyjny

Aby uzyskać powiązane informacje, zapoznaj się z pełny przewodnik OmniHuman v1.5, wyszczególnienie cen, przewodnik po filmach sprzedażowych i przewodnik wielojęzyczny.

Gotowy do spróbowania OmniHuman v1.5? Zacznij tworzyć za darmo →