Seedance 2.0 API: KI-Videos programmatisch generieren

Generiere ein kinematografisches KI-Video mit einer einzigen HTTP-Anfrage. Die Seedance 2.0 API ist dieselbe Generierungspipeline, die auch die Web-Plattform verwendet, als sauberes REST-Interface mit Bearer-Auth, Webhooks und Batch-Endpunkten. Wer einen POST-Request absetzen kann, kann eine Video-Generierungspipeline bauen.

Dieser Leitfaden behandelt alles, was du brauchst, um Seedance 2.0 in eigene Anwendungen zu integrieren: Authentifizierung, Endpunkte, Parameter, Fehlerbehandlung und produktionsreife Code-Beispiele in Python und JavaScript.

TL;DR - API auf einen Blick

• Basis-URL: https://api.arteza.ai/v1
• Auth: Bearer-Token im Authorization-Header
• Generierung: Asynchron - Task einreichen, per Polling oder Webhook auf Abschluss warten
• Ratenlimits: 60 Anfragen/Minute, 5 gleichzeitige Generierungen
• Modelle: Seedance 2.0, 1.0 Pro, 1.0 Lite, Seedream v3/v4.5/v5, alle in einer API
• Kreditkosten: Dieselbe dynamische Sekundenpreisgestaltung wie in der Web-Oberfläche (19-351 Credits für 2.0)

Was die API wirklich kann

Alles, was das Web-Interface kann, kann auch die API. Text-to-Video, Image-to-Video, Modellauswahl, Dauersteuerung, Seitenverhältnis, Audio-Umschalter und Zugriff auf jedes Modell der Plattform. Batch-Endpunkte für die gleichzeitige Generierung vieler Clips. Webhook-Benachrichtigungen, damit kein Polling nötig ist. Benutzerdefinierte Metadaten, die in den Ergebnissen zurückgegeben werden, ideal für A/B-Tests oder Kampagnenvarianten.

Unterstützte Modelle

Alle Modelle verwenden dieselbe API-Oberfläche, lediglich mit unterschiedlichen Bezeichnern.

Authentifizierung in 30 Sekunden

Erstelle einen API-Schlüssel im Dashboard unter Einstellungen > API-Schlüssel. Sende ihn als Bearer-Token:

curl -H "Authorization: Bearer YOUR_API_KEY" \
     https://api.arteza.ai/v1/account/credits

Antwort:

{
  "credits": 2750,
  "tier": "popular"
}

Sicherheitsregeln, die wichtig sind:

• Niemals den API-Schlüssel in clientseitigem Code oder öffentlichen Repos ausliefern
• In Umgebungsvariablen speichern (SEEDANCE_API_KEY)
• Schlüssel regelmäßig über das Dashboard rotieren
• Jeder Schlüssel erbt das Credit-Guthaben des übergeordneten Kontos

Der Text-to-Video-Endpunkt

Dies ist der Endpunkt, den du am häufigsten verwenden wirst.

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
}

Parameterreferenz

Erfolgreiche Antwort

{
  "task_id": "task_abc123def456",
  "status": "queued",
  "model": "seedance-2.0",
  "credits_charged": 607,
  "estimated_time": 120,
  "created_at": "2026-04-10T14:30:00Z"
}

Die Generierung erfolgt asynchron. Du erhältst sofort eine task_id und kannst den Abschluss per Polling prüfen (oder Webhooks verwenden).

Der Image-to-Video-Endpunkt

Animiere ein Quellbild mit einem Bewegungs-Prompt.

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

Du möchtest keine Datei hochladen? Übergib stattdessen eine 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"
}

Generierungsstatus prüfen

Frage den Task-Endpunkt ab, um den Fortschritt zu überprüfen.

GET /v1/tasks/{task_id}

Antwort bei laufender Verarbeitung

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

Antwort bei Abschluss

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

Statuswerte

Video-URLs laufen nach 24 Stunden ab. Lade sie herunter und speichere sie umgehend auf deiner eigenen Infrastruktur.

Möchtest du solche Ausgaben programmatisch generieren? Du bist 30 Sekunden von deinem ersten API-Aufruf entfernt. Hol dir deinen API-Schlüssel kostenlos →

Produktionsreifes Python-Beispiel

Hier ist ein vollständiges Skript, das eine Generierung einreicht, auf den Abschluss pollt und das Ergebnis herunterlädt.

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"):
    """Sendet einen Text-to-Video-Task. Gibt task_id zurück."""
    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):
    """Pollt, bis der Task abgeschlossen ist. Gibt result-Dict zurück."""
    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"Generierung fehlgeschlagen: {data.get('error')}")

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Task {task_id} wurde nicht innerhalb von {timeout}s abgeschlossen")


def download_video(video_url, output_path):
    """Streamt das Video auf die Festplatte."""
    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 eingereicht: {task_id}")

    result = wait_for_completion(task_id)
    print(f"Video bereit: {result['video_url']}")

    download_video(result["video_url"], "output.mp4")
    print("Heruntergeladen nach output.mp4")

JavaScript (Node.js)-Beispiel

Derselbe Ablauf in modernem Node.js mit nativem fetch.

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(`Generierung fehlgeschlagen: ${data.error}`);
    }

    await new Promise((resolve) => setTimeout(resolve, pollMs));
  }

  throw new Error(`Task ${taskId} hat das Zeitlimit überschritten`);
}

// Verwendung
const taskId = await generateVideo(
  "Timelapse of a flower blooming, macro lens, soft natural lighting",
  12
);
console.log(`Task eingereicht: ${taskId}`);

const result = await waitForCompletion(taskId);
console.log(`Video bereit: ${result.video_url}`);

Image-to-Video in Python

Wenn du ein Quellbild hochladen musst, verwende multipart/form-data:

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Generiert ein Video aus einer lokalen Bilddatei."""
    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"]

Fehlerbehandlung, die nicht abstürzt

Die API verwendet standardmäßige HTTP-Statuscodes mit strukturierten Fehlerkörpern.

Fehlerantwort-Format

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

Empfohlenes Muster

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"Benötigt {error['required_credits']} Credits, vorhanden {error['available_credits']}")
        # Nutzer zu /pricing weiterleiten
    elif status == 429:
        retry_after = int(e.response.headers.get("Retry-After", 60))
        print(f"Ratenlimit erreicht. Erneuter Versuch nach {retry_after}s.")
    else:
        raise

Ratenlimits und Best Practices für die Produktion

Die Limits

Fünf Praktiken, die in der Produktion wichtig sind

1. Webhooks statt Polling bei größerem Umfang verwenden. Polling verschwendet API-Aufrufe. Webhooks werden genau einmal ausgelöst.
2. Exponentiellen Backoff bei 429-Antworten einbauen. Nicht sofort neu versuchen.
3. Video-URLs zeitnah herunterladen. Sie laufen nach 24 Stunden ab. Auf dem eigenen CDN speichern.
4. Eingaben clientseitig validieren. Prompt-Länge und Dateigrößenprobleme abfangen, bevor die API getroffen wird.
5. Credit-Guthaben vor Batch-Jobs prüfen. Ein 402-Fehler mitten in einem Batch ist ärgerlich. Zuerst /account/credits abfragen.

Webhook-Integration

Füge webhook_url in die Generierungsanfrage ein, und Arteza sendet einen POST-Request, sobald der Task abgeschlossen ist.

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

Webhook-Payload

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

Webhook-Anfragen enthalten einen X-Seedance-Signature-Header, eine HMAC-SHA256-Signatur des Körpers, signiert mit deinem Webhook-Secret. Verifiziere die Signatur immer, bevor du Events verarbeitest.

Batch-Generierung

Wenn du mehrere Clips benötigst, reiche sie als Batch ein und erhalte einen einzigen Webhook, wenn alles abgeschlossen ist.

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

Tasks in einem Batch werden gleichzeitig bis zum Concurrency-Limit verarbeitet.

Vier Use Cases, die es wert sind, umgesetzt zu werden

1. E-Commerce-Produktvideos im großen Maßstab

Automatisiere die Produktanimation für deinen gesamten Katalog. Iteriere über deine Produktdatenbank, sende pro Artikel einen Image-to-Video-Aufruf und speichere die resultierenden URLs zusammen mit dem Produktdatensatz.

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)

Kombiniere das mit E-Commerce-Videoleitfaden für Workflow-Tipps.

2. Automatisierte Social-Media-Pipelines

Speise Trendthemen in Prompt-Generatoren ein, erstelle täglich vertikale Videos und schiebe sie in eine Review-Warteschlange:

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. Marketing-A/B-Tests

Generiere mehrere kreative Varianten mit Metadaten-Tracking:

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

Das Feld metadata wird im Abschluss-Payload zurückgegeben, sodass Ergebnisse automatisch dem richtigen Kampagnen-Bucket zugeordnet werden können.

4. Interaktive Anwendungen

Baue die Video-Generierung direkt in deine eigene App ein. Ein Nutzer gibt einen Prompt ein, dein Backend ruft die API auf, der Webhook liefert den fertigen Clip. Der gesamte Ablauf dauert etwa 90 Sekunden.

Das Fazit

Die Arteza API lässt sich unkompliziert integrieren und ist produktionsreif. Einfache Authentifizierung, saubere REST-Semantik, Webhooks für asynchrone Arbeit und Batch-Endpunkte für skalierbare Workloads. Wer Stripe oder eine andere moderne REST-API genutzt hat, fühlt sich in zehn Minuten heimisch.

Für Preise und Credit-Optimierung, siehe Preisleitfaden. Für den umfassenderen Produktüberblick, lies vollständiger Seedance 2.0-Leitfaden.

Bereit, mit dem Aufbau zu beginnen? Erstelle dein kostenloses Konto →

Weiterlesen: Vollständiger Seedance 2.0-Leitfaden • Preisleitfaden • Seedance 2.0 vs. Seedance 1.0 • Seedance 2.0 vs. Runway Gen-4