Seedance 2.0 API: Wie man AI-Videos programmgesteuert generiert

Erstelle ein cineastisches KI-Video mit einer HTTP-Anfrage. Die Seedance 2.0 API ist dieselbe Generierungs-Pipeline, die die Web-Plattform nutzt, aber als sauberes REST-Interface mit Bearer-Auth, Webhooks und Batch-Endpoints verfügbar gemacht. Wenn du eine POST-Anfrage stellen kannst, kannst du eine Video-Generierungs-Pipeline bauen.

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

TL;DR - API auf einen Blick

• Basis-URL: https://api.arteza.ai/v1
• Authentifizierung: Bearer-Token im Authorization-Header
• Generierung: Asynchron - sende eine Aufgabe, rufe ab oder nutze Webhooks für die Fertigstellung
• 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: Gleiche dynamische Preisberechnung pro Sekunde wie die Web-UI (~243-910 Credits für 2.0)

Was die API wirklich tun kann

Alles, was die Web-Oberfläche tut, kann die API auch. Text-zu-Video, Bild-zu-Video, Modellauswahl, Längenkontrolle, Seitenverhältnis, Audio-Umschalter und Zugang zu jedem Modell der Plattform. Batch-Endpoints zum Generieren vieler Clips auf einmal. Webhook-Benachrichtigungen, so dass du nicht abrufen musst. Benutzerdefinierte Metadaten, die in den Ergebnissen zurückgegeben werden, um A/B-Tests oder Kampagnenvarianten zu verfolgen.

Unterstützte Modelle

Alle Modelle nutzen die gleiche API-Oberfläche, nur mit verschiedenen Identifiern.

Authentifizierung in 30 Sekunden

Generiere einen API-Schlüssel aus dem 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:

• Versende deinen API-Schlüssel nie in clientseitigem Code oder öffentlichen Repos
• Speichere ihn in Umgebungsvariablen (SEEDANCE_API_KEY)
• Rotiere Schlüssel regelmäßig aus dem Dashboard
• Jeder Schlüssel erbt das Guthaben seines übergeordneten Kontos

Der Text-zu-Video-Endpoint

Das ist der Endpoint, den du am häufigsten nutzen 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
}

Parameter-Referenz

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 ist asynchron. Du erhältst sofort eine task_id und fragst auf Fertigstellung ab (oder nutzt Webhooks).

Der Bild-zu-Video-Endpoint

Animiere ein Quellbild mit einer Bewegungsanfrage.

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

Du möchtest keine Datei hochladen? Übergebe 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-Endpoint ab, um den Fortschritt zu überprüfen.

GET /v1/tasks/{task_id}

Antwort für laufende Generierung

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

Fertiggestellte Antwort

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

Status-Werte

Video-URLs verfallen in 24 Stunden. Lade sie schnell herunter und speichere sie auf deiner eigenen Infrastruktur.

Möchtest du programmgesteuert Ausgaben wie diese generieren? Du bist 30 Sekunden von deinem ersten API-Aufruf entfernt. Holen Sie sich Ihren API-Schlüssel kostenlos →

Produktionsreifes Python-Beispiel

Hier ist ein komplettes Skript, das eine Generierung einreicht, auf Fertigstellung wartet 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"):
    """Submit a text-to-video task. Returns task_id."""
    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):
    """Poll until the task finishes. Returns result dict."""
    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"Generation failed: {data.get('error')}")

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")


def download_video(video_url, output_path):
    """Stream the video to disk."""
    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 submitted: {task_id}")

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

    download_video(result["video_url"], "output.mp4")
    print("Downloaded to output.mp4")

JavaScript (Node.js) Beispiel

Der gleiche Workflow 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(`Generation failed: ${data.error}`);
    }

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

  throw new Error(`Task ${taskId} timed out`);
}

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

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

Bild-zu-Video in Python

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

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Generate video from a local image file."""
    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 zusammenbricht

Die API nutzt Standard-HTTP-Statuscodes mit strukturierten Error-Bodies.

Error-Antwort-Format

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

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"Need {error['required_credits']} credits, have {error['available_credits']}")
        # Redirect the user to /pricing
    elif status == 429:
        retry_after = int(e.response.headers.get("Retry-After", 60))
        print(f"Rate limited. Retry after {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. Nutze Webhooks, nicht Polling, im großen Maßstab. Polling verschwendet API-Aufrufe. Webhooks werden genau einmal ausgelöst.
2. Implementiere exponentielles Backoff bei 429-Antworten. Versuche nicht, sofort erneut aufzurufen.
3. Lade Video-URLs schnell herunter. Sie verfallen in 24 Stunden. Speichere sie auf deinem eigenen CDN.
4. Validiere Eingaben clientseitig. Fange Anfrage-Länge und Dateigröße-Probleme ab, bevor du die API triffst.
5. Prüfe Guthaben vor Batch-Jobs. Ein 402 mitten im Batch ist ärgerlich. Frage /account/credits zuerst ab.

Webhook-Integration

Füge webhook_url in deine Generierungsanfrage ein und Arteza wird dir einen POST-Request schicken, wenn die Aufgabe fertig 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 Body, signiert mit deinem Webhook-Secret. Überprüfe die Signatur immer vor der Verarbeitung von Events.

Batch-Generierung

Wenn du mehrere Clips brauchst, reiche sie als Batch ein und erhalte einen Webhook, wenn alles fertig 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"
}

Aufgaben in einem Batch werden gleichzeitig bis zu deinem Concurrency-Limit verarbeitet.

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

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

Automatisiere Produktanimation für deinen gesamten Katalog. Durchlaufe deine Produktdatenbank, starte pro Artikel einen Image-to-Video-Aufruf und speichere die resultierenden URLs neben 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-Video-Leitfaden für Workflow-Tipps.

2. Automatisierte Social-Media-Pipelines

Füttere Trend-Themen in Prompt-Generatoren, generiere täglich Videos im Hochformat, schiebe zu einer 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 metadata-Feld wird in der Abschluss-Payload zurückgegeben, so dass du Ergebnisse automatisch in den richtigen Kampagnen-Bucket weiterleiten kannst.

4. Interaktive Anwendungen

Baue Video-Generierung direkt in deine eigene App ein. Ein Benutzer tippt eine Anfrage, dein Backend ruft die API auf, der Webhook liefert den fertigen Clip. Die ganze Schleife dauert ~90 Sekunden.

Das Wichtigste

Die Arteza API ist einfach zu integrieren und produktionsreif. Einfache Auth, saubere REST-Semantik, Webhooks für asynchrone Arbeit und Batch-Endpoints für Skalierung. Wenn du Stripe oder eine andere moderne REST API verwendet hast, wirst du dich in zehn Minuten wie zu Hause fühlen.

Für Preis- und Credit-Optimierung siehe Preisleitfaden. Für die breiter gefasste Produktübersicht lies Vollständiger Seedance 2.0-Leitfaden.

Bereit, mit dem Bauen zu beginnen? Erstellen Sie kostenlos Ihr Konto →

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