Seedance 1.0 Pro API: Endpunkt für professionelle Videogenerierung

Wenn du Video in ein Produkt, einen Workflow oder eine Pipeline einbaust, wird die Web-Oberfläche früher oder später zum Engpass. Die Seedance 1.0 Pro API ist dasselbe Modell, das hinter der UI steckt, bereitgestellt als sauberer REST-Endpunkt mit Bearer-Token-Authentifizierung, vorhersehbarer Sekundenabrechnung und unkompliziertem Job-Polling. Diese Anleitung behandelt alles, was du brauchst, um es produktionsreif zu deployen.

Kurzfassung

• REST API für native 1080p-Videogenerierung mit Seedance 1.0 Pro
• Auth: Bearer Token aus deinem Konto-Dashboard
• Abrechnung: pro Sekunde zu etwa 0,12 Dollar/Sek., aufgerundet auf ganze Credits
• Ablauf: Job einreichen → Status abfragen → MP4 herunterladen
• Ideal für: SaaS-Integrationen, Batch-Pipelines, Automatisierung, White-Label-Produkte

Was die API bietet

Alles, was die Seedance 1.0 Pro-Web-Oberfläche bietet, programmatisch verfügbar:

• Bild-zu-Video-Generierung mit einer Quellbild-URL
• Motion Prompt zur Steuerung der Animation
• Dauersteuerung von 2 bis 12 Sekunden
• Endframe-Steuerung für gezielte Übergänge
• Kamerasperr-Schalter
• Job-Polling für Status und Ergebnis-URL
• MP4-Ausgabe in nativem 1080p

Verwende es für SaaS-Produkte mit integrierter Videogenerierung, interne Agentur-Pipelines, Batch-Produktions-Workflows oder die Automatisierung wiederkehrender Videoaufgaben.

Authentifizierung

Alle API-Aufrufe authentifizieren sich mit einem Bearer Token. Generiere einen über dein Arteza-Konto-Dashboard auf arteza.ai.

Authorization: Bearer YOUR_API_KEY

Sicherheitsregeln:

• API-Schlüssel niemals in die Versionskontrolle committen
• Schlüssel regelmäßig rotieren
• Umgebungsvariablen oder einen Secrets-Manager verwenden
• Schlüssel wenn möglich auf bestimmte Ursprünge beschränken

Die wichtigsten Endpunkte

Einen Generierungsjob einreichen

POST /v1/seedance-1-pro/generate

Request-Body:

{
  "source_image_url": "https://your-cdn.com/source.jpg",
  "prompt": "Slow camera push-in on the subject, warm golden hour light, shallow depth of field",
  "duration_seconds": 6,
  "camera_lock": false,
  "end_frame_url": null
}

Parameter:

Antwort:

{
  "job_id": "job_abc123xyz",
  "status": "queued",
  "created_at": "2026-04-10T12:00:00Z",
  "estimated_seconds": 90
}

Job-Status abfragen

GET /v1/seedance-1-pro/status/{job_id}

Antwort (in Bearbeitung):

{
  "job_id": "job_abc123xyz",
  "status": "processing",
  "progress": 0.45,
  "created_at": "2026-04-10T12:00:00Z"
}

Antwort (abgeschlossen):

{
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "resolution": "1920x1080",
  "credits_charged": 144
}

Mögliche Statuswerte: queued, processing, completed, failed

Das Ergebnis herunterladen

Sobald der Status completed ist, verweist video_url auf eine 1080p MP4-Datei. Lade sie sofort herunter und speichere sie in deiner eigenen Infrastruktur. Verlasse dich nicht darauf, dass die URL dauerhaft gültig bleibt.

Ein vollständiges Python-Beispiel

import os
import time
import requests

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1/seedance-1-pro"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def generate_video(source_image_url, prompt, duration=6, camera_lock=False, end_frame=None):
    payload = {
        "source_image_url": source_image_url,
        "prompt": prompt,
        "duration_seconds": duration,
        "camera_lock": camera_lock,
    }
    if end_frame:
        payload["end_frame_url"] = end_frame
    
    response = requests.post(f"{BASE_URL}/generate", headers=HEADERS, json=payload)
    response.raise_for_status()
    return response.json()["job_id"]

def wait_for_completion(job_id, poll_interval=5, timeout=300):
    start = time.time()
    while time.time() - start < timeout:
        r = requests.get(f"{BASE_URL}/status/{job_id}", headers=HEADERS)
        r.raise_for_status()
        data = r.json()
        
        if data["status"] == "completed":
            return data["video_url"]
        if data["status"] == "failed":
            raise RuntimeError(f"Job fehlgeschlagen: {data.get('error', 'unbekannt')}")
        
        time.sleep(poll_interval)
    
    raise TimeoutError(f"Job {job_id} wurde nicht innerhalb von {timeout}s abgeschlossen")

def download_video(url, output_path):
    response = requests.get(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)

# Verwendung
job_id = generate_video(
    source_image_url="https://example.com/product.jpg",
    prompt="Slow camera orbit around the product, studio lighting, 6 seconds",
    duration=6,
    camera_lock=True
)

video_url = wait_for_completion(job_id)
download_video(video_url, "output.mp4")
print(f"Video gespeichert unter output.mp4")

Ein vollständiges Node.js-Beispiel

import fs from 'fs';
import fetch from 'node-fetch';

const API_KEY = process.env.SEEDANCE_API_KEY;
const BASE_URL = 'https://api.arteza.ai/v1/seedance-1-pro';
const HEADERS = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

async function generateVideo(opts) {
  const response = await fetch(`${BASE_URL}/generate`, {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(opts)
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  const data = await response.json();
  return data.job_id;
}

async function waitForCompletion(jobId, { pollInterval = 5000, timeout = 300000 } = {}) {
  const start = Date.now();
  while (Date.now() - start < timeout) {
    const r = await fetch(`${BASE_URL}/status/${jobId}`, { headers: HEADERS });
    const data = await r.json();
    if (data.status === 'completed') return data.video_url;
    if (data.status === 'failed') throw new Error(`Job fehlgeschlagen: ${data.error}`);
    await new Promise(res => setTimeout(res, pollInterval));
  }
  throw new Error('Timeout');
}

async function downloadVideo(url, path) {
  const response = await fetch(url);
  const buffer = await response.buffer();
  fs.writeFileSync(path, buffer);
}

// Verwendung
const jobId = await generateVideo({
  source_image_url: 'https://example.com/product.jpg',
  prompt: 'Slow camera orbit around the product, studio lighting, 6 seconds',
  duration_seconds: 6,
  camera_lock: true
});

const videoUrl = await waitForCompletion(jobId);
await downloadVideo(videoUrl, 'output.mp4');
console.log('output.mp4 gespeichert');

Broadcast-Qualität wie diese? Seedance 1.0 Pro kostenlos testen →

Preise und Abrechnung

Tarif: etwa $0,12 pro Sekunde des Ausgabevideos, aufgerundet auf den nächsten ganzen Credit

Credits werden nur bei erfolgreichen Generierungen abgezogen. Fehlgeschlagene Jobs verbrauchen keine Credits.

Die Pläne sind dieselben wie bei der Web-Oberfläche: $5 Starter, $25 Creator, $50 Pro, $120 Studio. Siehe Preisseite.

Ratenlimits und Parallelität

Standardkonten haben Ratenlimits, die für typische Integrationslasten geeignet sind. Für hochvolumige Produktion wende dich an den Support, um höhere Limits zu erhalten.

Allgemeine Empfehlungen:

• 5-10 parallele Jobs sind für die meisten Konten zuverlässig
• Exponentielles Backoff bei HTTP-429-Antworten
• Wiederholungen auf Job-Ebene bei vorübergehenden Fehlern (bis zu 3 Versuche)
• Webhook-Callbacks sind verfügbar, um übermäßiges Polling zu vermeiden

Webhooks (optional)

Anstatt zu pollen, registriere eine Webhook-URL in deinen Kontoeinstellungen oder pro Anfrage. Wenn ein Job abgeschlossen ist, sendet Arteza einen POST an deine URL:

{
  "event": "job.completed",
  "job_id": "job_abc123xyz",
  "status": "completed",
  "video_url": "https://arteza.ai/videos/abc123xyz.mp4",
  "duration_seconds": 6,
  "credits_charged": 144,
  "timestamp": "2026-04-10T12:02:15Z"
}

Webhooks sind mit einer HMAC-Signatur im Header X-Seedance-Signature signiert. Verifiziere diese, bevor du dem Payload vertraust.

Fehlerbehandlung

Die API gibt standardmäßige HTTP-Statuscodes zurück:

Fehler-Response-Bodies enthalten ein Feld error mit einer menschenlesbaren Nachricht sowie ein Feld code für die programmatische Verarbeitung.

{
  "error": "Source image URL could not be fetched",
  "code": "source_image_unreachable"
}

Anforderungen an das Eingabebild

• Formate: PNG, JPEG, WebP
• Größe: bis zu 10 MB pro Bild
• Auflösung: mindestens 512x512, höher ist besser (1080p+ empfohlen)
• URL-Zugriff: muss von den Arteza-Servern öffentlich erreichbar sein (kein localhost, keine authentifizierungsgeschützten URLs)

Für private Bilder lade sie auf eine signierte S3-URL, CloudFront oder Ähnliches hoch und übergib die signierte URL in der Anfrage.

Best Practices

1. Ausgaben in der eigenen Infrastruktur speichern. Verlasse dich nicht langfristig auf Arteza-URLs.
2. Alles protokollieren. Job-IDs, Prompts, Zeitstempel, Statusübergänge, Fehler.
3. Vorübergehende Fehler wiederholen. Netzwerkprobleme und 5xx-Antworten sollten mit exponentiellem Backoff wiederholt werden.
4. Eingaben frühzeitig validieren. Bild-URLs und Parameterbereiche vor dem Einreichen prüfen.
5. Credit-Guthaben überwachen. Benachrichtigung einrichten, wenn es unter einen Schwellenwert fällt.
6. Webhooks für die Produktion verwenden. Polling ist für kleine Lasten in Ordnung, bei großem Volumen jedoch ineffizient.
7. Identische Generierungen cachen. Wenn ein Nutzer dasselbe Bild und denselben Prompt zweimal einreicht, die gecachte URL zurückgeben.

Tests und Staging

Starte jede Integration mit dem $5-Starter-Plan (60 Credits pro Monat). Das reicht für zwanzig 2-sekündige Test-Generierungen. Baue und teste die Integration von Anfang bis Ende, bevor du dich für einen Plan mit höherem Volumen entscheidest.

Anwendungsfälle

• SaaS-Plattformen: Nutzer können Videos aus eigenen Assets generieren
• E-Commerce: Produktvideos aus Katalogbildern generieren
• Immobilien: Listing-Videoproduktion aus Fotos automatisieren
• Marketing-Automatisierung: personalisierte Videos in großem Maßstab
• Content-Plattformen: Artikel, Listings oder Social-Media-Beiträge mit generierten Videos anreichern
• White-Label-Videowerkzeuge: eigenes KI-Videoprodukt auf dem Arteza-Backend aufbauen

Weiterführende Lektüre

• Batch-Verarbeitungs-Workflows
• Vollständiger Leitfaden zu Seedance 1.0 Pro
• Seedance 1.0 Pro für Agenturen
• Seedance 2.0 API-Leitfaden

FAQ

Kann ich die API für kommerzielle Anwendungen nutzen? Ja, alle Ausgaben sind zur kommerziellen Nutzung freigegeben.

Was passiert, wenn die Generierung fehlschlägt? Bei fehlgeschlagenen Generierungen werden keine Credits abgezogen.

Wie lange werden generierte Videos gehostet? Videos stehen nach der Generierung für einen bestimmten Zeitraum zum Download bereit. Lade sie herunter und speichere sie zeitnah.

Werden SDK-Bibliotheken unterstützt? Community-SDKs für Python und Node sind verfügbar. Siehe die Entwicklerdokumentation auf arteza.ai.

Kann ich einen laufenden Job abbrechen? Ja, sende DELETE /v1/seedance-1-pro/jobs/{job_id}. Bei abgebrochenen Jobs werden keine Credits berechnet.

Wie erhalte ich Support? Nutze den E-Mail-Support über dein Konto-Dashboard für API-spezifische Fragen.

---

Die Seedance 1.0 Pro API ist der produktionsreife Weg, um 1080p-KI-Videogenerierung in dein Produkt oder deine Pipeline zu integrieren.

API-Schlüssel holen und mit dem Aufbau beginnen → mit 10 kostenlosen Credits inklusive bei der Registrierung.