Seedance 2.0 API: Vollständiger Integrationsleitfaden (2026)

curl -X POST https://api.seedance.ai/v2/generate/text \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0",
    "prompt": "A golden retriever running through a field of sunflowers at sunset, slow motion, cinematic lighting",
    "aspect_ratio": "16:9",
    "duration": 4
  }'

curl https://api.seedance.ai/v2/tasks/TASK_ID \
  -H "Authorization: Bearer YOUR_API_KEY"

const SEEDANCE_API_KEY = process.env.SEEDANCE_API_KEY

const headers = {
  'Authorization': `Bearer ${SEEDANCE_API_KEY}`,
  'Content-Type': 'application/json',
}

import os
import requests

SEEDANCE_API_KEY = os.environ["SEEDANCE_API_KEY"]

headers = {
    "Authorization": f"Bearer {SEEDANCE_API_KEY}",
    "Content-Type": "application/json",
}

curl -H "Authorization: Bearer $SEEDANCE_API_KEY" \
     -H "Content-Type: application/json" \
     https://api.seedance.ai/v2/account

async function generateTextToVideo(prompt) {
  const response = await fetch('https://api.seedance.ai/v2/generate/text', {
    method: 'POST',
    headers,
    body: JSON.stringify({
      model: 'seedance-2.0',
      prompt,
      aspect_ratio: '16:9',
      duration: 4,
    }),
  })

  const data = await response.json()

  if (!data.data?.task_id) {
    throw new Error(`Generation failed: ${data.error?.message ?? 'Unknown error'}`)
  }

  return data.data.task_id
}

def generate_text_to_video(prompt: str) -> str:
    response = requests.post(
        "https://api.seedance.ai/v2/generate/text",
        headers=headers,
        json={
            "model": "seedance-2.0",
            "prompt": prompt,
            "aspect_ratio": "16:9",
            "duration": 4,
        },
    )
    response.raise_for_status()
    data = response.json()

    task_id = data.get("data", {}).get("task_id")
    if not task_id:
        raise ValueError(f"Generation failed: {data.get('error', {}).get('message', 'Unknown')}")

    return task_id

async function generateImageToVideo(imagePath, motionPrompt) {
  const imageBuffer = await fs.promises.readFile(imagePath)
  const blob = new Blob([imageBuffer], { type: 'image/png' })

  const formData = new FormData()
  formData.append('model', 'seedance-2.0')
  formData.append('image', blob, 'input.png')
  formData.append('motion_prompt', motionPrompt)
  formData.append('duration', '4')

  const response = await fetch('https://api.seedance.ai/v2/generate/image', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${SEEDANCE_API_KEY}` },
    body: formData,
  })

  const data = await response.json()
  return data.data.task_id
}

async function generateImageToVideoFromUrl(imageUrl, motionPrompt) {
  const response = await fetch('https://api.seedance.ai/v2/generate/image', {
    method: 'POST',
    headers,
    body: JSON.stringify({
      model: 'seedance-2.0',
      image_url: imageUrl,
      motion_prompt: motionPrompt,
      duration: 4,
    }),
  })

  const data = await response.json()
  return data.data.task_id
}

def generate_image_to_video(image_path: str, motion_prompt: str) -> str:
    with open(image_path, "rb") as f:
        files = {"image": ("input.png", f, "image/png")}
        data = {
            "model": "seedance-2.0",
            "motion_prompt": motion_prompt,
            "duration": "4",
        }

        response = requests.post(
            "https://api.seedance.ai/v2/generate/image",
            headers={"Authorization": f"Bearer {SEEDANCE_API_KEY}"},
            files=files,
            data=data,
        )

    response.raise_for_status()
    return response.json()["data"]["task_id"]

async function pollForResult(taskId, maxAttempts = 60, intervalMs = 3000) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const response = await fetch(
      `https://api.seedance.ai/v2/tasks/${taskId}`,
      { headers }
    )
    const data = await response.json()
    const status = data.data?.status

    if (status === 'completed') {
      return data.data.video_url
    }

    if (status === 'failed') {
      throw new Error(`Generation failed: ${data.data?.error ?? 'Unknown error'}`)
    }

    await new Promise((resolve) => setTimeout(resolve, intervalMs))
  }

  throw new Error('Generation timed out after maximum polling attempts')
}

import time

def poll_for_result(task_id: str, max_attempts: int = 60, interval: float = 3.0) -> str:
    for _ in range(max_attempts):
        response = requests.get(
            f"https://api.seedance.ai/v2/tasks/{task_id}",
            headers=headers,
        )
        response.raise_for_status()
        data = response.json()["data"]

        if data["status"] == "completed":
            return data["video_url"]

        if data["status"] == "failed":
            raise RuntimeError(f"Generation failed: {data.get('error', 'Unknown')}")

        time.sleep(interval)

    raise TimeoutError("Generation timed out")

// Webhook-Endpunkt registrieren
async function registerWebhook(url) {
  const response = await fetch('https://api.seedance.ai/v2/webhooks', {
    method: 'POST',
    headers,
    body: JSON.stringify({
      url,
      events: ['generation.completed', 'generation.failed'],
    }),
  })

  return response.json()
}

{
  "event": "generation.completed",
  "task_id": "task_abc123",
  "status": "completed",
  "video_url": "https://cdn.seedance.ai/results/...",
  "duration": 4,
  "created_at": "2026-02-11T10:30:00Z",
  "completed_at": "2026-02-11T10:31:15Z"
}

app.post('/webhooks/seedance', express.json(), (req, res) => {
  const { event, task_id, video_url, status } = req.body

  if (event === 'generation.completed') {
    // Abgeschlossenes Video verarbeiten
    processCompletedVideo(task_id, video_url)
  }

  if (event === 'generation.failed') {
    // Fehler behandeln
    handleGenerationFailure(task_id)
  }

  res.status(200).json({ received: true })
})

{
  "status": "error",
  "error": {
    "code": "RATE_LIMITED",
    "message": "Rate limit exceeded. Retry after 30 seconds.",
    "retry_after": 30
  }
}

async function apiRequestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, options)

    if (response.ok) {
      return response.json()
    }

    if (response.status === 429) {
      const data = await response.json()
      const retryAfter = data.error?.retry_after ?? 30
      await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000))
      continue
    }

    if (response.status >= 500) {
      const backoffMs = Math.pow(2, attempt) * 1000
      await new Promise((resolve) => setTimeout(resolve, backoffMs))
      continue
    }

    const errorData = await response.json()
    throw new Error(`API error ${response.status}: ${errorData.error?.message ?? 'Unknown'}`)
  }

  throw new Error('Maximum retries exceeded')
}

def api_request_with_retry(method: str, url: str, max_retries: int = 3, **kwargs) -> dict:
    for attempt in range(max_retries):
        response = requests.request(method, url, headers=headers, **kwargs)

        if response.ok:
            return response.json()

        if response.status_code == 429:
            retry_after = response.json().get("error", {}).get("retry_after", 30)
            time.sleep(retry_after)
            continue

        if response.status_code >= 500:
            time.sleep(2 ** attempt)
            continue

        response.raise_for_status()

    raise RuntimeError("Maximum retries exceeded")

X-RateLimit-Limit: 10
X-RateLimit-Remaining: 7
X-RateLimit-Reset: 1707654321

async function processBatch(prompts) {
  const concurrencyLimit = 5
  const results = []

  for (let i = 0; i < prompts.length; i += concurrencyLimit) {
    const batch = prompts.slice(i, i + concurrencyLimit)

    const batchResults = await Promise.allSettled(
      batch.map(async (prompt) => {
        const taskId = await generateTextToVideo(prompt)
        const videoUrl = await pollForResult(taskId)
        return { prompt, videoUrl }
      })
    )

    const settled = batchResults.map((result) =>
      result.status === 'fulfilled'
        ? result.value
        : { error: result.reason.message }
    )

    results.push(...settled)
  }

  return results
}

Client → API Gateway → Nachrichtenwarteschlange → Worker Pool → Seedance API
                                            ↓
                                       Status Store → Webhook / Polling

async function checkUsage() {
  const response = await fetch('https://api.seedance.ai/v2/account', {
    headers,
  })
  const data = await response.json()

  return {
    plan: data.data.plan,
    usedToday: data.data.generations_today,
    limitToday: data.data.generations_limit,
    billingCycleSpend: data.data.current_spend,
  }
}