DEV Community: EvoLink

Seedance 2.0 API Tutorial: From Zero to Your First AI Video (Python)

EvoLink — Sat, 28 Feb 2026 16:32:47 +0000

Seedance 2.0 is ByteDance's most advanced AI video model — multimodal references, native audio, cinematic camera control, and 4–15 second generation at up to 1080p. This tutorial walks you through the entire API workflow in Python: from getting your API key to downloading your first generated video.

By the end, you'll have working code for text-to-video, image-to-video, async polling, webhook handling, and error recovery. Every code example here was tested against a live API.

Note — Seedance 2.0 vs 1.5: Seedance 2.0 is rolling out progressively. You can test the complete workflow right now using seedance-1.5-pro — when 2.0 is fully available, just change the model name. All endpoints, parameters, and response formats are identical. The key differences in 2.0: multimodal references (mix images, videos, and audio as inputs), native audio generation, improved physics simulation, and video editing capabilities. Everything in this tutorial works with both versions.

Get your free API key to follow along.

What You'll Build (and What You Need)

Here's what a Seedance-generated video looks like — created with a single API call:

A girl reaches for a leather-bound book in a grand library. Generated by Seedance with a single text prompt.

In this tutorial, you'll write Python code that:

Sends a text prompt → gets back a generated video
Sends an image → animates it into a video
Polls for results asynchronously
Handles errors and retries like production code
Receives results via webhook (no polling needed)
Cancels in-progress tasks when needed

Prerequisites

Python 3.8+ (check with python3 --version)
requests library (pip install requests)
An EvoLink API key (free to sign up — we'll get this in the next section)

No GPU, no Docker, no complex setup. Just Python and an API key.

Pro Tip: If you're building a production app, consider using a virtual environment to isolate dependencies:
python3 -m venv seedance-env
source seedance-env/bin/activate  # macOS/Linux
seedance-env\Scripts\activate     # Windows
pip install requests flask

Get Your API Key

Seedance 2.0 is available through EvoLink, an API gateway that provides unified access to multiple AI video models — including Seedance 2.0, Kling, and others — through a single API key.

Here's how to get started:

Go to evolink.ai/early-access and create an account
Navigate to Dashboard → API Keys
Click Create New Key
Copy your key — it starts with sk-

Store your key securely. Don't commit it to version control. We'll use an environment variable:

export EVOLINK_API_KEY="sk-your-api-key-here"

This line sets the EVOLINK_API_KEY environment variable in your terminal session. On macOS/Linux, add it to your ~/.bashrc or ~/.zshrc to persist across sessions. On Windows, use set EVOLINK_API_KEY=sk-your-api-key-here in Command Prompt, or set it in System Properties → Environment Variables for persistence.

Your account includes starter credits to experiment with. Check the Getting Started docs for current pricing details.

Common Mistake: Don't hardcode your API key in source files. If you push it to GitHub, automated scrapers will find it within minutes. Always use environment variables or a secrets manager like AWS Secrets Manager or HashiCorp Vault.

Set Up Your Python Environment

Install the one dependency you need:

pip install requests

Create a file called seedance_tutorial.py and add this setup code. Every example in this tutorial builds on this foundation:

import requests
import time
import os
import json

# ── Configuration ─────────────────────────────────────────────
API_KEY = os.getenv("EVOLINK_API_KEY", "sk-your-api-key-here")
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

Let's break this down line by line:

os.getenv("EVOLINK_API_KEY", "sk-your-api-key-here") — Reads the API key from the environment variable. The second argument is a fallback default (replace this with your actual key only for local testing).
BASE_URL — The root URL for all EvoLink API endpoints. All requests go to https://api.evolink.ai/v1/....
HEADERS — Two headers sent with every request: Authorization carries your API key using the Bearer token scheme, and Content-Type tells the server we're sending JSON.

Now add the reusable helper functions:

# ── Reusable Polling Helper ───────────────────────────────────
def wait_for_video(task_id, poll_interval=10, timeout=600):
    """
    Poll a video generation task until it completes or fails.

    Args:
        task_id: The task ID returned by the generation endpoint.
        poll_interval: Seconds between polls (default 10).
        timeout: Maximum wait time in seconds (default 600).

    Returns:
        dict: The completed task response with video URLs.

    Raises:
        TimeoutError: If the task doesn't complete within the timeout.
        RuntimeError: If the task fails.
    """
    elapsed = 0
    while elapsed < timeout:
        # Send GET request to check the task's current status
        response = requests.get(
            f"{BASE_URL}/tasks/{task_id}",
            headers=HEADERS
        )
        # Raise an exception if the HTTP status code indicates an error
        response.raise_for_status()
        task = response.json()

        # Extract status and progress from the response
        status = task["status"]
        progress = task.get("progress", 0)
        print(f"  [{elapsed}s] Status: {status} | Progress: {progress}%")

        # Check terminal states
        if status == "completed":
            return task
        elif status == "failed":
            error_info = task.get("error", {})
            raise RuntimeError(
                f"Task {task_id} failed: {error_info.get('message', 'Unknown error')}"
            )

        # Wait before the next poll
        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Task {task_id} timed out after {timeout}s")

Key design decisions in this function:

poll_interval=10 — 10 seconds is the sweet spot. Faster wastes API quota; slower delays your workflow.
timeout=600 — 10 minutes is generous. Most videos complete in 30–120 seconds, but this covers edge cases like queue congestion.
response.raise_for_status() — Converts HTTP errors (4xx/5xx) into Python exceptions so they don't silently pass.
Progress printing — The [elapsed]s prefix helps you correlate timing. Useful for debugging slow generations.

# ── Helper: Download Video ────────────────────────────────────
def download_video(url, filename="output.mp4"):
    """Download a video file from a URL."""
    print(f"Downloading video to {filename}...")
    resp = requests.get(url, stream=True)
    resp.raise_for_status()
    with open(filename, "wb") as f:
        for chunk in resp.iter_content(chunk_size=8192):
            f.write(chunk)
    print(f"Saved: {filename} ({os.path.getsize(filename) / 1024:.0f} KB)")

This function streams the download in 8 KB chunks instead of loading the entire video into memory. This matters — generated videos can be 10–50 MB. The stream=True parameter tells requests to download incrementally.

These three pieces — configuration, polling, and download — are the foundation. Every code example below uses them. We won't repeat them — just the new payload each time.

For the full API reference, see the Video Generation docs.

Generate Your First Video (Text-to-Video)

Time to generate a video. Add this to your script:

# ── Text-to-Video ─────────────────────────────────────────────
def text_to_video():
    payload = {
        "model": "seedance-2.0",          # The AI model to use
        "prompt": (
            "A golden retriever puppy chases a butterfly through "
            "a sunlit meadow. The camera follows the puppy with a "
            "smooth tracking shot as wildflowers sway in the breeze."
        ),
        "duration": 5,                     # Video length: 4-15 seconds
        "quality": "720p",                 # Resolution: 480p, 720p, 1080p
        "aspect_ratio": "16:9",            # Standard widescreen
        "generate_audio": True             # AI generates matching audio
    }

    print("Submitting text-to-video request...")
    response = requests.post(
        f"{BASE_URL}/videos/generations",  # The video generation endpoint
        headers=HEADERS,                   # Auth + content-type headers
        json=payload                       # Automatically serializes to JSON
    )
    response.raise_for_status()            # Throw if not 200 OK
    task = response.json()                 # Parse the JSON response

    # Log key info from the response
    print(f"Task created: {task['id']}")
    print(f"Estimated time: {task['task_info']['estimated_time']}s")
    print(f"Credits reserved: {task['usage']['credits_reserved']}")

    # Poll until the video is ready
    result = wait_for_video(task["id"])

    # The results array contains one or more video URLs
    video_url = result["results"][0]
    print(f"\nVideo URL: {video_url}")
    download_video(video_url, "my_first_video.mp4")

    return result


if __name__ == "__main__":
    text_to_video()

Let's walk through each parameter in the payload:

model — Which Seedance model to use. Set seedance-2.0 for the latest; use seedance-1.5-pro if 2.0 isn't available in your region yet.
prompt — Your video description. Be specific about subject, action, camera movement, and mood. The prompt above uses a three-part structure: subject ("golden retriever puppy"), action ("chases a butterfly"), and camera ("smooth tracking shot"). For advanced prompt techniques, see our Prompt Engineering Guide.
duration — Video length in seconds (4–15). Shorter videos generate faster and cost fewer credits. Start with 5 for testing.
quality — Resolution tier. 720p is the best balance of quality and speed for development. Use 480p for rapid iteration, 1080p for final renders.
aspect_ratio — Output dimensions. 16:9 for YouTube/landscape, 9:16 for TikTok/Reels/Shorts, 1:1 for Instagram feed.
generate_audio — When true, Seedance generates ambient sound and music that matches the visual content. Adds ~2 seconds to generation time.

Run it:

python seedance_tutorial.py

What the API Returns

When you submit a generation request, you get back a task object immediately — the video isn't ready yet. Here's the actual response:

{
  "created": 1772203771,
  "id": "task-unified-1772203771-yf1dxogh",
  "model": "seedance-2.0",
  "object": "video.generation.task",
  "progress": 0,
  "status": "pending",
  "task_info": {
    "can_cancel": true,
    "estimated_time": 132
  },
  "type": "video",
  "usage": {
    "billing_rule": "per_second",
    "credits_reserved": 17.784,
    "user_group": "default"
  }
}

Key fields explained:

Field	Meaning
`id`	Your task ID — use this to check status and retrieve results
`status`	Starts as `pending`, moves to `processing`, then `completed` or `failed`
`progress`	0–100 percentage. Updates in real-time during `processing`
`estimated_time`	Approximate seconds until completion (server-side estimate)
`credits_reserved`	Credits held for this job. Refunded automatically if the task fails
`task_info.can_cancel`	Whether you can cancel this task (always `true` before completion)
`created`	Unix timestamp of when the task was submitted
`usage.billing_rule`	How credits are calculated — `per_second` means cost scales with duration

Pro Tip: Save the id to a file or database immediately after submission. If your script crashes during polling, you can resume by calling wait_for_video() with the saved task ID. Tasks persist on the server for 24 hours.

The Polling Sequence

The wait_for_video() function polls every 10 seconds. Here's what the real output looks like:

Submitting text-to-video request...
Task created: task-unified-1772203771-yf1dxogh
Estimated time: 132s
Credits reserved: 17.784
  [0s] Status: pending | Progress: 0%
  [10s] Status: processing | Progress: 7%
  [20s] Status: processing | Progress: 13%
  [30s] Status: processing | Progress: 20%
  [40s] Status: processing | Progress: 27%
  [50s] Status: completed | Progress: 100%

Video URL: https://files.evolink.ai/.../cgt-20260227224931-8vl7s.mp4
Downloading video to my_first_video.mp4...
Saved: my_first_video.mp4 (2847 KB)

That's it — about 50 seconds from API call to video file on disk.

Important: Video URLs expire after 24 hours. Always download the file promptly or store it in your own storage (S3, GCS, Cloudflare R2, etc.).

Common Mistake: Don't rely on the video URL for long-term storage. Build your pipeline to download immediately after completion. If you're processing videos asynchronously, use webhooks (covered below) to trigger downloads the moment they're ready.

For tips on writing effective prompts, see the Seedance 2.0 Prompt Guide — it covers shot-script format, style keywords, and timing syntax.

Poll for Results: Understanding the Async Workflow

Video generation takes 30–120+ seconds depending on duration and quality. The API uses an asynchronous task pattern — the same pattern used by OpenAI, Stability AI, and most other generative AI APIs:

Submit → POST to /v1/videos/generations → get a task ID instantly
Poll → GET /v1/tasks/{task_id} → check status periodically
Retrieve → When status: "completed", the results array contains video URLs

This pattern exists because video generation is computationally expensive. A synchronous HTTP request would time out long before the video is ready.

Task Status Lifecycle

pending → processing → completed
                    ↘ failed

Status	What's Happening	Typical Duration
`pending`	Task is queued, waiting for GPU resources	0–30 seconds
`processing`	Video is being generated — `progress` updates in real-time	30–120 seconds
`completed`	Done! `results` array has your video URL(s)	Terminal state
`failed`	Something went wrong — check the error details	Terminal state

Polling Best Practices

Poll interval: 10 seconds is a good default. Polling too fast wastes requests and could trigger rate limits; too slow delays your pipeline. For time-critical applications, you can poll every 5 seconds, but there's no benefit to going faster than that.

Timeout: Set a reasonable upper limit based on your parameters:

Configuration	Expected Time	Suggested Timeout
4s, 480p	20–40 seconds	120 seconds
5s, 720p	30–60 seconds	180 seconds
10s, 720p	60–90 seconds	300 seconds
15s, 1080p	90–180 seconds	600 seconds

Progress tracking: The progress field (0–100) gives you granular feedback — useful for building progress bars in a UI. Progress updates roughly every 5–7 seconds during the processing phase.

Cancelling a Task

If you need to stop a generation in progress (wrong prompt, changed your mind), you can cancel it:

def cancel_task(task_id):
    """Cancel a pending or processing task. Credits are refunded."""
    response = requests.post(
        f"{BASE_URL}/tasks/{task_id}/cancel",
        headers=HEADERS
    )
    if response.status_code == 200:
        print(f"Task {task_id} cancelled. Credits refunded.")
    else:
        print(f"Cancel failed: {response.json()}")

Cancellation works when task_info.can_cancel is true. Once a task reaches completed or failed, it can't be cancelled. Reserved credits are refunded automatically on cancellation.

Pro Tip: Build a cancellation mechanism into your UI early. Users will inevitably submit wrong prompts, and waiting 2 minutes for a bad video wastes both time and credits.

The wait_for_video() function from our setup code handles the standard polling flow. If you want to skip polling entirely, jump to the Webhooks section below.

Animate an Image (Image-to-Video)

Got a product photo, character illustration, or landscape you want to bring to life? Pass it as an image_url and Seedance will animate it. This is one of the most powerful features for e-commerce product videos — take a static product shot and turn it into an engaging video ad.

Uses the same setup and polling function from the first example above.

# ── Image-to-Video ────────────────────────────────────────────
def image_to_video():
    payload = {
        "model": "seedance-2.0",
        "prompt": (
            "@Image1 as the first frame. The scene slowly comes "
            "to life — leaves rustle gently, soft light shifts "
            "across the frame, and the subject blinks naturally."
        ),
        "image_urls": [
            "https://example.com/your-image.jpg"
        ],
        "duration": 5,
        "quality": "720p",
        "aspect_ratio": "16:9"
    }

    print("Submitting image-to-video request...")
    response = requests.post(
        f"{BASE_URL}/videos/generations",
        headers=HEADERS,
        json=payload
    )
    response.raise_for_status()
    task = response.json()

    print(f"Task created: {task['id']}")
    result = wait_for_video(task["id"])

    video_url = result["results"][0]
    download_video(video_url, "animated_image.mp4")

    return result

Let's unpack what's different from text-to-video:

image_urls — An array of publicly accessible image URLs. The API fetches these directly, so they must be reachable from the internet (not localhost or private network URLs).
@Image1 in the prompt — This tag tells Seedance which image to reference and how. It corresponds to the first URL in image_urls. If you pass three images, you'd use @Image1, @Image2, @Image3.
No generate_audio — Omitted here, which defaults to true. You can set it to false for silent animation.

How @Image Tags Work

The @Image1 tag in your prompt tells Seedance how to use the image. It references the first URL in the image_urls array. You can pass up to 9 images (@Image1 through @Image9). For a complete guide on multimodal tags including @Video and @Audio, see the Multimodal @Tags Guide.

Common patterns:

Prompt Pattern	What It Does	Best For
`@Image1 as first frame`	Uses the image as the opening frame	Product showcases, scene setting
`@Image1 as last frame`	Uses the image as the closing frame	Logo reveals, transitions
`@Image1 as character reference`	Maintains the character's appearance	Consistent characters across clips
`@Image1 as style reference`	Applies the image's visual style	Brand consistency, art direction
`@Image1 as first frame, @Image2 as last frame`	Creates a transition between two images	Before/after, transformations

The actual response from our test:

{
  "created": 1772204037,
  "id": "task-unified-1772204036-lify8u5p",
  "model": "seedance-2.0",
  "object": "video.generation.task",
  "progress": 0,
  "status": "pending",
  "task_info": {
    "can_cancel": true,
    "estimated_time": 145
  },
  "type": "video",
  "usage": {
    "billing_rule": "per_second",
    "credits_reserved": 17.784,
    "user_group": "default"
  }
}

Image-to-video follows the exact same async pattern — submit, poll, download. The estimated_time is slightly longer because the model needs to analyze the input image.

Image Requirements

Constraint	Value
Max images	9 per request
Max file size	30 MB per image
Supported formats	JPEG, PNG, WebP, BMP, TIFF, GIF
URL requirement	Must be publicly accessible
Recommended resolution	At least 720px on the shorter side

Common Mistake: Passing a local file path instead of a URL. The image_urls field requires publicly accessible HTTP/HTTPS URLs. If your images are local, upload them to S3, Cloudflare R2, or even a temporary file hosting service first.

Restriction: Seedance does not support uploading realistic human face images. The system automatically rejects them. Use illustrated or stylized characters instead.

Hosting Images for the API

If you don't have a CDN, here are quick options for getting a public URL:

# Option 1: Upload to S3 (if you have AWS)
import boto3
s3 = boto3.client('s3')
s3.upload_file('local_image.jpg', 'my-bucket', 'seedance/input.jpg')
image_url = f"https://my-bucket.s3.amazonaws.com/seedance/input.jpg"

# Option 2: Use a temporary file hosting API
# Many services offer free temporary hosting for testing

For advanced image-to-video techniques — first-last frame control, multi-image composition, and e-commerce product animation — see the Image-to-Video deep dive.

Customize Your Videos

Every parameter you can tune in a generation request:

Parameter	Type	Default	Options	Description
`model`	string	—	`seedance-2.0`	Required. The model to use.
`prompt`	string	—	≤2000 tokens	Required. Video description with optional @tags.
`duration`	integer	5	4–15	Video length in seconds.
`quality`	string	`720p`	`480p`, `720p`, `1080p`	Resolution tier. Higher = more credits.
`aspect_ratio`	string	`16:9`	`16:9`, `9:16`, `1:1`, `4:3`, `3:4`, `21:9`	Output aspect ratio.
`generate_audio`	boolean	`true`	`true`, `false`	Enable AI-generated audio/music.
`image_urls`	array	—	≤9 images	Reference images. Use @Image1, @Image2... in prompt.
`video_urls`	array	—	≤3 videos	Reference videos. Use @Video1, @Video2... in prompt.
`audio_urls`	array	—	≤3 audio files	Reference audio. Use @Audio1, @Audio2... in prompt.
`callback_url`	string	—	HTTPS URL	Webhook for completion notification.

Seedance 2.0 vs 1.5 Note: All parameters above work with both seedance-2.0 and seedance-1.5-pro. The key difference: video_urls, audio_urls, and multi-image references (@Image2 through @Image9) are 2.0-only features. If you use them with 1.5, the API returns a 400 error with a clear message indicating the feature isn't supported.

Quick Examples

Vertical video for social media (TikTok/Reels):

Uses the same setup and polling function from the first example above.

payload = {
    "model": "seedance-2.0",
    "prompt": "A barista pours latte art in slow motion. Close-up overhead shot.",
    "duration": 8,
    "quality": "1080p",
    "aspect_ratio": "9:16",       # Vertical for mobile
    "generate_audio": True
}

The 9:16 aspect ratio generates a 1080×1920 video — native resolution for TikTok, Instagram Reels, and YouTube Shorts. The 1080p quality tier ensures crisp visuals on mobile screens.

Cinematic widescreen with camera movement:

payload = {
    "model": "seedance-2.0",
    "prompt": (
        "Aerial drone shot over a misty mountain range at sunrise. "
        "Camera slowly pushes forward, revealing a hidden valley. "
        "Cinematic color grading, volumetric lighting."
    ),
    "duration": 10,
    "quality": "1080p",
    "aspect_ratio": "21:9",       # Ultra-widescreen cinematic
    "generate_audio": True
}

For programmatic camera control — dolly zooms, orbital shots, and Hitchcock-style movements — see the Camera Movement API Guide.

Silent video for a website background:

payload = {
    "model": "seedance-2.0",
    "prompt": "Abstract flowing particles in deep blue and gold. Slow, meditative movement.",
    "duration": 15,               # Max duration for seamless loops
    "quality": "720p",
    "aspect_ratio": "21:9",       # Wide background
    "generate_audio": False       # No audio for autoplay backgrounds
}

Budget-friendly draft (fast iteration):

payload = {
    "model": "seedance-2.0",
    "prompt": "A cat wearing sunglasses sits at a DJ booth. Neon club lighting.",
    "duration": 4,                # Minimum duration = fastest generation
    "quality": "480p",            # Lowest quality = cheapest credits
    "aspect_ratio": "16:9"
}

Pro Tip: During development, always use duration: 4 and quality: "480p". This is the cheapest and fastest combination — ideal for iterating on prompts. Once you're happy with the content, render the final version at 1080p with your desired duration.

Credit Cost Estimation

Credits scale with duration and quality. Here's a rough guide:

Quality	4s	5s	10s	15s
480p	~8	~10	~20	~30
720p	~14	~18	~36	~53
1080p	~22	~28	~55	~83

Approximate credits. Actual costs shown in credits_reserved field. Check the EvoLink dashboard for current rates.

The multimodal reference system — @Image, @Video, @Audio tags — is where Seedance 2.0 truly shines. You can replicate camera movements from reference videos, maintain character consistency across shots, and sync to audio beats. For a complete guide, read The Ultimate Guide to @Tags.

Handle Errors Gracefully

API calls fail. Networks drop. Rate limits hit. Here's how to build resilient code that handles every real error scenario.

Common Error Responses

Every error follows the same format:

{
  "error": {
    "message": "description of what went wrong",
    "type": "error_category",
    "code": "specific_error_code"
  }
}

The error object always contains message and type. The code field is present for most errors but not all. Always check type first, then code for specifics.

Here are real error responses from the API:

401 — Invalid API Key:

{
  "error": {
    "message": "Invalid token (request id: 20260227225245660301729AApJNAhJ)",
    "type": "evo_api_error"
  }
}

This means your API key is wrong, expired, or was revoked. Double-check the EVOLINK_API_KEY environment variable. A common cause: copying the key with trailing whitespace.

400 — Missing Required Field:

{
  "error": {
    "code": "invalid_parameter",
    "message": "prompt cannot be empty",
    "type": "invalid_request_error"
  }
}

The prompt field is required for all generation requests. This also triggers if you pass an empty string or whitespace-only prompt.

400 — Invalid Parameter Value:

{
  "error": {
    "code": "invalid_parameter",
    "message": "duration must be between 4 and 15",
    "type": "invalid_request_error"
  }
}

Happens when you pass duration: 3 or duration: 20. The valid range is 4–15 seconds inclusive.

400 — Unsupported Quality Tier:

{
  "error": {
    "code": "invalid_parameter",
    "message": "quality must be one of: 480p, 720p, 1080p",
    "type": "invalid_request_error"
  }
}

Common when passing "quality": "4k" or "quality": "hd". Use the exact strings: 480p, 720p, or 1080p.

402 — Insufficient Credits:

{
  "error": {
    "message": "Insufficient credits. Required: 17.784, Available: 2.100",
    "type": "insufficient_quota_error"
  }
}

Your account doesn't have enough credits. The message tells you exactly how many you need vs. how many you have. Top up at the EvoLink dashboard.

404 — Task Not Found:

{
  "error": {
    "message": "Task not found",
    "type": "invalid_request_error",
    "code": "task_not_found"
  }
}

Usually means the task ID is wrong, or the task was created more than 24 hours ago (tasks expire). Double-check you're using the id field from the creation response, not some other field.

413 — Image Too Large:

{
  "error": {
    "message": "Image file size exceeds 30MB limit",
    "type": "request_too_large_error"
  }
}

Compress your image before uploading. For the API, visual quality above 2–3 MB rarely improves results.

429 — Rate Limited:

{
  "error": {
    "message": "Rate limit exceeded. Please retry after 60 seconds.",
    "type": "rate_limit_error"
  }
}

You're sending too many requests. The default limit is generous for development, but batch scripts can hit it. Implement exponential backoff (see below).

422 — Content Moderation Rejection:

{
  "error": {
    "message": "Content rejected by safety filter",
    "type": "content_policy_violation",
    "code": "content_filtered"
  }
}

Your prompt or input images triggered the content moderation system. Rephrase your prompt to avoid restricted content. Realistic human faces in image_urls are automatically rejected.

Error Reference Table

HTTP Code	Type	Meaning	Retryable?	Action
400	`invalid_request_error`	Bad parameters	No	Fix your payload
401	`authentication_error`	Invalid API key	No	Verify your key
402	`insufficient_quota_error`	Out of credits	No	Top up your account
404	`not_found_error`	Task or model not found	No	Check task_id / model name
413	`request_too_large_error`	Payload too big	No	Reduce file sizes
422	`content_policy_violation`	Content filtered	No	Rephrase prompt
429	`rate_limit_error`	Too many requests	Yes	Wait 60s, retry
500	`internal_server_error`	Server issue	Yes	Retry after a few seconds
502	`bad_gateway`	Upstream error	Yes	Retry after 5s
503	`service_unavailable_error`	Service down	Yes	Retry after 30s

Production-Ready Error Handling

Wrap your API calls with retry logic for transient errors:

Uses the same setup and polling function from the first example above.

import random

def generate_video_with_retry(payload, max_retries=3):
    """
    Submit a video generation request with automatic retry
    for transient errors (429, 500, 502, 503).

    Uses exponential backoff with jitter to avoid thundering herd:
    - Attempt 1: wait ~1s
    - Attempt 2: wait ~2s  
    - Attempt 3: wait ~4s

    Non-retryable errors (400, 401, 402, 404, 413, 422) fail immediately
    because retrying won't fix the underlying problem.
    """
    for attempt in range(max_retries):
        try:
            response = requests.post(
                f"{BASE_URL}/videos/generations",
                headers=HEADERS,
                json=payload,
                timeout=30       # 30s connection timeout
            )

            # Success — return the task object
            if response.status_code == 200:
                return response.json()

            # Parse the error response
            error = response.json().get("error", {})
            error_type = error.get("type", "")
            error_msg = error.get("message", "Unknown error")

            # Non-retryable errors — fail immediately
            if response.status_code in (400, 401, 402, 404, 413, 422):
                raise ValueError(
                    f"API error {response.status_code}: {error_msg}"
                )

            # Retryable errors — exponential backoff with jitter
            if response.status_code in (429, 500, 502, 503):
                wait = (2 ** attempt) + random.uniform(0, 1)
                print(f"  Retry {attempt + 1}/{max_retries} "
                      f"after {wait:.1f}s ({error_type}: {error_msg})")
                time.sleep(wait)
                continue

        except requests.exceptions.Timeout:
            # Server didn't respond within 30 seconds
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"  Timeout. Retry {attempt + 1}/{max_retries} "
                  f"after {wait:.1f}s")
            time.sleep(wait)
            continue

        except requests.exceptions.ConnectionError as e:
            # DNS failure, refused connection, etc.
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"  Connection error: {e}. Retry {attempt + 1}/{max_retries} "
                  f"after {wait:.1f}s")
            time.sleep(wait)
            continue

    raise RuntimeError(f"Failed after {max_retries} retries")

This handles:

Rate limits (429) — exponential backoff with jitter avoids synchronized retries from multiple clients
Server errors (500/502/503) — automatic retry with increasing delay
Timeouts — 30-second timeout prevents hanging on unresponsive servers
Connection drops — DNS failures, refused connections, network blips
Client errors (400/401/402/404/413/422) — fail immediately because retrying won't fix bad input

Pro Tip: For production systems, consider logging failed requests with their full payload and error response. This makes debugging much easier when things go wrong at 3 AM.

Validating Input Before API Calls

Save credits and time by catching obvious errors locally:

def validate_payload(payload):
    """
    Validate a generation payload before sending to the API.
    Catches common mistakes that would result in 400 errors.
    """
    errors = []

    # Required fields
    if not payload.get("model"):
        errors.append("'model' is required")
    if not payload.get("prompt") or not payload["prompt"].strip():
        errors.append("'prompt' is required and cannot be empty")

    # Duration range
    duration = payload.get("duration", 5)
    if duration < 4 or duration > 15:
        errors.append(f"'duration' must be 4-15, got {duration}")

    # Quality values
    valid_qualities = {"480p", "720p", "1080p"}
    quality = payload.get("quality", "720p")
    if quality not in valid_qualities:
        errors.append(f"'quality' must be one of {valid_qualities}, got '{quality}'")

    # Aspect ratio values
    valid_ratios = {"16:9", "9:16", "1:1", "4:3", "3:4", "21:9"}
    ratio = payload.get("aspect_ratio", "16:9")
    if ratio not in valid_ratios:
        errors.append(f"'aspect_ratio' must be one of {valid_ratios}, got '{ratio}'")

    # Image URL validation
    image_urls = payload.get("image_urls", [])
    if len(image_urls) > 9:
        errors.append(f"Maximum 9 images allowed, got {len(image_urls)}")
    for i, url in enumerate(image_urls):
        if not url.startswith(("http://", "https://")):
            errors.append(f"image_urls[{i}] must be an HTTP(S) URL")

    if errors:
        raise ValueError(f"Payload validation failed:\n" + "\n".join(f"  - {e}" for e in errors))

    return True

Common Mistake: Forgetting to URL-encode special characters in image URLs. If your image path contains spaces or non-ASCII characters, use urllib.parse.quote() to encode it.

Set Up Webhooks (Skip the Polling)

Polling works fine for scripts and prototyping. For production systems, webhooks are more efficient — the API pushes the result to your server when the video is ready. No wasted requests, no delay between completion and notification.

How It Works

Add callback_url to your generation request:

Uses the same setup from the first example above.

payload = {
    "model": "seedance-2.0",
    "prompt": "A spaceship launches from a desert landscape at sunset.",
    "duration": 8,
    "quality": "720p",
    "callback_url": "https://your-server.com/api/webhook/seedance"
}

response = requests.post(
    f"{BASE_URL}/videos/generations",
    headers=HEADERS,
    json=payload
)
task = response.json()
print(f"Task submitted: {task['id']}")
# No polling needed — your webhook will receive the result

When the video is ready, the API sends a POST request to your callback_url with the completed task object — the exact same payload you'd get from polling.

Webhook Requirements

Requirement	Details
Protocol	HTTPS only (no HTTP) — required for security
Response	Return 2xx within 10 seconds
Retries	3 attempts on failure (1s, 2s, 4s intervals)
URL length	≤ 2048 characters
Network	No internal/private IPs (localhost, 10.x.x.x, 192.168.x.x)
Body	JSON POST with the full task object

Production Flask Webhook Receiver

Here's a complete webhook server using Flask with proper validation, error handling, and async video downloading:

# webhook_server.py
"""
Seedance webhook receiver — handles video completion callbacks.
Run: pip install flask requests
      python webhook_server.py
"""
from flask import Flask, request, jsonify
import json
import os
import threading
import requests as req  # renamed to avoid conflict with flask.request

app = Flask(__name__)

# Directory to save completed videos
OUTPUT_DIR = os.getenv("VIDEO_OUTPUT_DIR", "./videos")
os.makedirs(OUTPUT_DIR, exist_ok=True)


def download_video_async(video_url, task_id):
    """Download video in a background thread to not block the webhook response."""
    try:
        filename = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")
        print(f"  Downloading {task_id} to {filename}...")
        resp = req.get(video_url, stream=True, timeout=120)
        resp.raise_for_status()
        with open(filename, "wb") as f:
            for chunk in resp.iter_content(chunk_size=8192):
                f.write(chunk)
        size_mb = os.path.getsize(filename) / (1024 * 1024)
        print(f"  Saved: {filename} ({size_mb:.1f} MB)")
    except Exception as e:
        print(f"  Download failed for {task_id}: {e}")


@app.route("/api/webhook/seedance", methods=["POST"])
def handle_webhook():
    """
    Handle Seedance video completion webhook.

    The API sends a POST with the full task object when
    a video generation completes (success or failure).
    """
    # Parse the incoming task object
    task = request.json
    if not task:
        return jsonify({"error": "Empty body"}), 400

    task_id = task.get("id", "unknown")
    status = task.get("status", "unknown")
    model = task.get("model", "unknown")

    print(f"\n{'='*50}")
    print(f"Webhook received: task={task_id}")
    print(f"  Status: {status}")
    print(f"  Model: {model}")

    if status == "completed":
        # Extract video URL(s) from results
        results = task.get("results", [])
        if results:
            video_url = results[0]
            print(f"  Video URL: {video_url}")

            # Download in background thread so we respond quickly
            thread = threading.Thread(
                target=download_video_async,
                args=(video_url, task_id)
            )
            thread.start()
        else:
            print(f"  WARNING: Completed but no results array!")

    elif status == "failed":
        error_info = task.get("error", {})
        print(f"  FAILED: {json.dumps(error_info, indent=2)}")
        # TODO: Log to your error tracking system (Sentry, etc.)
        # TODO: Optionally retry the generation with modified parameters

    else:
        print(f"  Unexpected status: {status}")
        print(f"  Full payload: {json.dumps(task, indent=2)}")

    # Always return 200 quickly — the API expects a response within 10s
    return jsonify({"received": True, "task_id": task_id}), 200


@app.route("/health", methods=["GET"])
def health_check():
    """Health check endpoint for load balancers."""
    return jsonify({"status": "ok"}), 200


if __name__ == "__main__":
    print(f"Starting webhook server...")
    print(f"Videos will be saved to: {os.path.abspath(OUTPUT_DIR)}")
    print(f"Webhook URL: http://localhost:5000/api/webhook/seedance")
    app.run(host="0.0.0.0", port=5000, debug=True)

Install dependencies and run:

pip install flask requests
python webhook_server.py

Key design decisions in this server:

Background downloads — We spawn a thread to download the video so the webhook handler returns 200 immediately. The API expects a response within 10 seconds; video downloads can take longer.
Health check endpoint — /health is useful when deploying behind a load balancer (ALB, nginx, etc.).
Error logging — Failed tasks are printed with the full error payload. In production, pipe this to Sentry, Datadog, or your logging stack.

Exposing Localhost with ngrok

For local development, use ngrok to create a public HTTPS URL that tunnels to your local server:

# Install ngrok (macOS)
brew install ngrok

# Or download from https://ngrok.com/download

# Start the tunnel
ngrok http 5000

ngrok outputs something like:

Forwarding  https://a1b2c3d4.ngrok-free.app → http://localhost:5000

Use that HTTPS URL as your callback_url:

payload = {
    "model": "seedance-2.0",
    "prompt": "Your prompt here",
    "callback_url": "https://a1b2c3d4.ngrok-free.app/api/webhook/seedance"
}

Common Mistake: Using the http:// ngrok URL instead of https://. The Seedance API requires HTTPS for webhooks — it will reject plain HTTP callback URLs with a 400 error.

Webhook Security

In production, validate that webhook requests actually come from the EvoLink API:

import hmac
import hashlib

def verify_webhook(request):
    """Verify webhook authenticity using the task ID pattern."""
    task = request.json
    task_id = task.get("id", "")

    # EvoLink task IDs follow a specific format
    if not task_id.startswith("task-unified-"):
        return False

    # Additional validation: check required fields exist
    required_fields = ["id", "status", "model", "created"]
    if not all(field in task for field in required_fields):
        return False

    return True

When to Use Webhooks vs Polling

Scenario	Recommendation	Why
Quick prototyping / scripts	Polling	Simpler, no server needed
Production web app	Webhooks	Scalable, no wasted requests
Batch processing (100+ videos)	Webhooks + queue	Submit all, process as they complete
CLI tools	Polling	No server infrastructure required
Mobile app backend	Webhooks	Push notifications to users on completion
Serverless (Lambda/Cloud Functions)	Webhooks	Perfect fit — function triggered per completion

Pro Tip: For batch processing, combine webhooks with a message queue (Redis, RabbitMQ, SQS). Submit all generation requests, then process completions as they arrive on the queue. This decouples submission from processing and handles retries gracefully.

Batch Processing: Generate Multiple Videos

Real-world use cases often involve generating many videos. Here's a pattern for batch processing with rate limiting:

Uses the same setup and helper functions from the first example above.

import concurrent.futures

def batch_generate(prompts, max_concurrent=3):
    """
    Generate multiple videos with controlled concurrency.

    Args:
        prompts: List of prompt strings.
        max_concurrent: Maximum simultaneous generations.

    Returns:
        List of (prompt, result_or_error) tuples.
    """
    results = []

    def generate_one(prompt, index):
        """Generate a single video and return the result."""
        payload = {
            "model": "seedance-2.0",
            "prompt": prompt,
            "duration": 5,
            "quality": "720p"
        }
        try:
            task = generate_video_with_retry(payload)
            print(f"[{index}] Submitted: {task['id']}")
            result = wait_for_video(task["id"])
            video_url = result["results"][0]
            download_video(video_url, f"batch_{index}.mp4")
            return (prompt, result)
        except Exception as e:
            print(f"[{index}] Failed: {e}")
            return (prompt, str(e))

    # Process in batches to respect rate limits
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_concurrent) as executor:
        futures = {
            executor.submit(generate_one, prompt, i): i
            for i, prompt in enumerate(prompts)
        }
        for future in concurrent.futures.as_completed(futures):
            results.append(future.result())

    # Summary
    succeeded = sum(1 for _, r in results if isinstance(r, dict))
    print(f"\nBatch complete: {succeeded}/{len(prompts)} succeeded")
    return results


# Example usage
prompts = [
    "A hummingbird hovering near a red flower. Macro lens, shallow depth of field.",
    "Ocean waves crashing on volcanic rocks at sunset. Slow motion.",
    "A street musician playing violin in the rain. Cinematic lighting.",
]
batch_generate(prompts, max_concurrent=2)

Key considerations for batch processing:

max_concurrent=3 — Don't submit too many requests simultaneously. Start with 2–3 and increase based on your rate limits.
ThreadPoolExecutor — Uses threads (not processes) because we're I/O-bound (waiting for API responses), not CPU-bound.
Error isolation — Each video generation is independent. One failure doesn't stop the batch.

What's Next

You've covered the fundamentals — text-to-video, image-to-video, async polling, webhooks, error handling, and batch processing. Here's where to go deeper:

Explore Advanced Features

@Tags Multimodal Reference Guide — Master the @Image, @Video, @Audio reference system for multi-modal generation
Camera Movement API Guide — Replicate Hitchcock zooms, one-take tracking shots, and orbital cameras programmatically
Image-to-Video Deep Dive — First-last frame control, multi-image composition, e-commerce product videos
E-commerce Product Video Guide — Turn product photos into marketing videos at scale
Prompt Engineering Guide — Shot-script format, timing syntax, and the prompts behind our demo videos

Reference Docs

Build Something

Combine what you've learned. Here are a few project ideas:

Automated product video pipeline — Upload product photos, generate marketing videos in bulk (see our E-commerce Video Guide)
Social media content engine — Generate short-form vertical videos from text briefs, post directly to TikTok/Reels
Storyboard-to-video tool — Turn sequential images into animated scenes with camera movement control
AI video editing pipeline — Use Seedance 2.0's video extension to create longer narratives from shorter clips

Ready to build? Get your free EvoLink API key and start generating videos today.

Frequently Asked Questions

How long does Seedance 2.0 video generation take?

Typically 30–120 seconds depending on duration and quality settings. A 5-second 720p video completes in about 50 seconds. A 15-second 1080p video can take 2–3 minutes. The API returns an estimated_time field with each task so you can set appropriate timeouts. During peak hours, queue wait times may add 10–30 seconds to the total.

What image formats does the Seedance 2.0 API accept?

JPEG, PNG, WebP, BMP, TIFF, and GIF. Each image must be under 30 MB. You can pass up to 9 images per request via the image_urls parameter. Images must be publicly accessible URLs — the API fetches them directly. For best results, use images that are at least 720px on the shorter side. Very low-resolution images (below 256px) may produce blurry animations.

Can I generate videos longer than 15 seconds?

The maximum single generation is 15 seconds. For longer content, generate multiple clips and concatenate them using FFmpeg or any video editor. Seedance 2.0 supports video extension — you can use a generated video's last frame as the first frame of the next generation to create seamless continuity. Here's the basic approach: generate clip 1, extract the last frame, pass it as @Image1 as first frame for clip 2.

How much does Seedance 2.0 API cost through EvoLink?

Pricing is based on video duration and quality tier. A 5-second 720p video costs approximately 18 credits. EvoLink provides smart routing that can reduce costs compared to direct API access. Check your dashboard for current per-second rates. The credits_reserved field in the API response shows the exact cost before generation begins — you'll never be charged more than that amount.

What's the difference between seedance-1.5-pro and seedance-2.0?

Seedance 2.0 adds multimodal references (mix images, videos, and audio as inputs), native audio generation, improved physics and consistency, and video editing capabilities. The API interface is identical — same endpoint, same parameters, same response format. You can test with seedance-1.5-pro today and switch to seedance-2.0 by changing the model name. Key 1.5 limitations: single image input only (no @Image2–9), no video/audio references, no native audio generation. See the Seedance 2.0 vs Sora 2 comparison for benchmarks.

How do I handle the "content rejected by safety filter" error?

The content moderation system rejects prompts involving realistic violence, explicit content, and real public figures. It also rejects realistic human face images uploaded via image_urls. To work around face restrictions, use illustrated, stylized, or anime-style character images. For prompt rejections, rephrase to be less specific about restricted topics. The error response includes type: "content_policy_violation" — check for this in your error handling code to give users a clear message.

Can I use the Seedance API in a Node.js / JavaScript project?

Yes. The REST API is language-agnostic — any HTTP client works. The concepts in this tutorial (async polling, webhooks, error handling) apply directly to Node.js with fetch or axios. EvoLink also provides official Node.js and Python SDKs that handle polling and retries for you.

What happens if my webhook server is down when the video completes?

The API retries webhook delivery 3 times with increasing intervals (1s, 2s, 4s). If all 3 retries fail, the webhook is abandoned — but the video is still available. You can always fall back to polling with GET /v1/tasks/{task_id} to retrieve the result. For this reason, it's good practice to store the task ID on submission and have a background job that periodically checks for any tasks that completed but weren't received via webhook.

Is there a rate limit on API requests?

Yes. The default rate limit is generous for development and moderate production use. If you hit a 429 error, implement exponential backoff as shown in the error handling section. For high-volume use cases (thousands of videos per day), contact EvoLink support to discuss custom rate limits and dedicated capacity.

Can I use Seedance 2.0 for commercial projects?

Yes. Videos generated through the EvoLink API are licensed for commercial use. You own the output and can use it in products, marketing materials, client deliverables, and published content. See the Seedance 2.0 copyright guide for detailed licensing terms and best practices for commercial use.

Complete Script

Here's the full tutorial code in a single file — copy, paste, add your API key, and run:

"""
Seedance 2.0 API Tutorial — Complete Script
Docs: https://seedance2api.app/docs/video-generation
API Key: https://evolink.ai/early-access
"""
import requests
import time
import os
import json
import random

# ── Configuration ─────────────────────────────────────────────
API_KEY = os.getenv("EVOLINK_API_KEY", "sk-your-api-key-here")
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}


# ── Reusable Helpers ──────────────────────────────────────────
def wait_for_video(task_id, poll_interval=10, timeout=600):
    """Poll a video generation task until completion."""
    elapsed = 0
    while elapsed < timeout:
        response = requests.get(
            f"{BASE_URL}/tasks/{task_id}",
            headers=HEADERS
        )
        response.raise_for_status()
        task = response.json()
        status = task["status"]
        progress = task.get("progress", 0)
        print(f"  [{elapsed}s] Status: {status} | Progress: {progress}%")
        if status == "completed":
            return task
        elif status == "failed":
            raise RuntimeError(f"Task {task_id} failed: {task}")
        time.sleep(poll_interval)
        elapsed += poll_interval
    raise TimeoutError(f"Task {task_id} timed out after {timeout}s")


def download_video(url, filename="output.mp4"):
    """Download a video file from a URL."""
    print(f"Downloading to {filename}...")
    resp = requests.get(url, stream=True)
    resp.raise_for_status()
    with open(filename, "wb") as f:
        for chunk in resp.iter_content(chunk_size=8192):
            f.write(chunk)
    print(f"Saved: {filename} ({os.path.getsize(filename) / 1024:.0f} KB)")


def generate_video_with_retry(payload, max_retries=3):
    """Submit a generation request with retry for transient errors."""
    for attempt in range(max_retries):
        try:
            response = requests.post(
                f"{BASE_URL}/videos/generations",
                headers=HEADERS,
                json=payload,
                timeout=30
            )
            if response.status_code == 200:
                return response.json()
            error = response.json().get("error", {})
            if response.status_code in (400, 401, 402, 404, 413, 422):
                raise ValueError(
                    f"API error {response.status_code}: "
                    f"{error.get('message', 'Unknown')}"
                )
            if response.status_code in (429, 500, 502, 503):
                wait = (2 ** attempt) + random.uniform(0, 1)
                print(f"  Retry {attempt+1}/{max_retries} after {wait:.1f}s")
                time.sleep(wait)
                continue
        except requests.exceptions.RequestException:
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"  Retry {attempt+1}/{max_retries} after {wait:.1f}s")
            time.sleep(wait)
            continue
    raise RuntimeError(f"Failed after {max_retries} retries")


def validate_payload(payload):
    """Validate generation payload before API call."""
    errors = []
    if not payload.get("model"):
        errors.append("'model' is required")
    if not payload.get("prompt") or not payload["prompt"].strip():
        errors.append("'prompt' is required")
    duration = payload.get("duration", 5)
    if duration < 4 or duration > 15:
        errors.append(f"'duration' must be 4-15, got {duration}")
    quality = payload.get("quality", "720p")
    if quality not in {"480p", "720p", "1080p"}:
        errors.append(f"Invalid quality: {quality}")
    if errors:
        raise ValueError("Validation failed:\n" + "\n".join(f"  - {e}" for e in errors))


def cancel_task(task_id):
    """Cancel a pending or processing task."""
    response = requests.post(
        f"{BASE_URL}/tasks/{task_id}/cancel",
        headers=HEADERS
    )
    if response.status_code == 200:
        print(f"Task {task_id} cancelled.")
    else:
        print(f"Cancel failed: {response.json()}")


# ── Example 1: Text-to-Video ─────────────────────────────────
def text_to_video():
    payload = {
        "model": "seedance-2.0",
        "prompt": (
            "A golden retriever puppy chases a butterfly through "
            "a sunlit meadow. The camera follows the puppy with a "
            "smooth tracking shot as wildflowers sway in the breeze."
        ),
        "duration": 5,
        "quality": "720p",
        "aspect_ratio": "16:9",
        "generate_audio": True
    }
    validate_payload(payload)
    task = generate_video_with_retry(payload)
    print(f"Task: {task['id']} (ETA: {task['task_info']['estimated_time']}s)")
    result = wait_for_video(task["id"])
    download_video(result["results"][0], "text_to_video.mp4")


# ── Example 2: Image-to-Video ────────────────────────────────
def image_to_video():
    payload = {
        "model": "seedance-2.0",
        "prompt": (
            "@Image1 as the first frame. The scene slowly comes "
            "to life — leaves rustle gently, soft light shifts "
            "across the frame."
        ),
        "image_urls": ["https://example.com/your-image.jpg"],
        "duration": 5,
        "quality": "720p"
    }
    validate_payload(payload)
    task = generate_video_with_retry(payload)
    print(f"Task: {task['id']}")
    result = wait_for_video(task["id"])
    download_video(result["results"][0], "image_to_video.mp4")


# ── Example 3: Vertical Social Media Video ───────────────────
def social_media_video():
    payload = {
        "model": "seedance-2.0",
        "prompt": (
            "A barista pours latte art in slow motion. "
            "Close-up overhead shot, warm cafe lighting."
        ),
        "duration": 8,
        "quality": "1080p",
        "aspect_ratio": "9:16",
        "generate_audio": True
    }
    validate_payload(payload)
    task = generate_video_with_retry(payload)
    print(f"Task: {task['id']}")
    result = wait_for_video(task["id"])
    download_video(result["results"][0], "social_video.mp4")


if __name__ == "__main__":
    print("=== Text-to-Video ===")
    text_to_video()
    # print("\n=== Image-to-Video ===")
    # image_to_video()  # Uncomment and set your image URL
    # print("\n=== Social Media Video ===")
    # social_media_video()

Tip: To test with the currently available model, change "seedance-2.0" to "seedance-1.5-pro". The API interface is identical — same endpoint, same parameters, same response format. When Seedance 2.0 is fully rolled out, just switch the model name back.

Start building → Get your free API key at EvoLink

I Tested Seedance 2.0 vs Sora 2 with Identical Prompts — Here Are the Real Results

EvoLink — Mon, 23 Feb 2026 17:45:35 +0000

Seedance 2.0 vs Sora 2: Real API Tests with Identical Prompts (2026)

Most "Seedance vs Sora" articles compare spec sheets. We ran both models through the same three prompts, recorded the outputs, and scored them frame by frame. Here's what we found — with video evidence, API code you can copy, and a pricing breakdown that might change which model you pick.

Seedance 2.0 (by ByteDance's Seed team) scored 8.5/10 overall versus Sora 2's 8.0/10 across our tests. The gap wasn't where we expected it.

Want to run these tests yourself? Get a free EvoLink API key and use the exact prompts below.

The Test Setup

We designed three prompts to stress-test different capabilities:

Slow-motion physics — a porcelain vase shattering (particle dynamics, material rendering)
Dynamic human motion — rooftop breakdancing at night (anatomy, motion blur, neon lighting)
Facial expression & lighting — an elderly woman discovering a magical book (micro-expressions, volumetric light)

Methodology: Each prompt was submitted verbatim to both APIs. No cherry-picking — we used the first generation from each model. Videos are 15 seconds, unedited. Scoring uses six dimensions: image quality, prompt adherence, physics/anatomy realism, lighting, motion fluidity, and detail richness.

Why this matters: If you're building a product on top of an AI video API, you need to know which model handles your use case. Spec sheets won't tell you that Sora 2's human anatomy breaks down on pause, or that Seedance's 60fps makes slow-motion scenes noticeably smoother.

Every existing "Seedance vs Sora" article we found relies on feature-list comparisons or single cherry-picked examples. None uses controlled, identical prompts with systematic scoring. That's the gap this test fills.

What we didn't test: We didn't evaluate text-overlay quality, multi-scene narratives, or audio-sync accuracy in this round. Those deserve their own dedicated tests. We also limited ourselves to text-to-video mode — image-to-video and video-to-video comparisons are planned for a follow-up.

Parameter	Seedance 2.0	Sora 2
Resolution	1280×720 (720p)	1792×1024 (~1080p)
Frame Rate	60fps	30fps
Duration	15s	15s
Codec	H.264	H.264
Audio	AAC 44.1kHz stereo	AAC 96kHz stereo

Seedance trades resolution for double the frame rate. Sora delivers ~2.5× more pixels per frame. Both choices have real consequences for different content types — as you'll see below.

A quick note on audio: both models generate synchronized audio (dialogue, SFX, music), but their sample rates differ. Sora's 96kHz output exceeds CD quality, while Seedance's 44.1kHz matches standard CD audio. In practice, most delivery platforms (YouTube, TikTok, Instagram) downsample to 48kHz or lower, so this difference rarely matters for final distribution.

Test 1 — Slow-Motion Physics (Porcelain Vase)

Prompt:

A porcelain vase falls from a marble table in slow motion. Camera starts with a close-up of the vase wobbling on the edge, then follows it downward with a smooth tracking shot as it shatters on a stone floor. Fragments scatter in all directions. Dust particles float in warm afternoon sunlight streaming through a window. Shallow depth of field, 24fps cinematic look

Seedance 2.0

▶️ Watch video

Dimension	Score	Notes
Image Quality	8.5/10	Near-cinematic. Blue-white porcelain texture crisp, marble grain realistic
Prompt Adherence	7.5/10	Vase, marble table, warm light, shallow DoF — all present. Dust particles missing
Physics Realism	7.0/10	Fall trajectory reasonable but fragments cluster too tightly. Missing motion blur gives a "floating" feel
Lighting	9.0/10	Afternoon warmth from window is consistent. Specular highlights on glaze are accurate

Standout: The bokeh and warm-light rendering feel genuinely filmic. At 60fps, the slow-motion fall is buttery smooth — you can track individual fragments frame by frame without any judder. The blue-white porcelain glaze catches afternoon light exactly the way real celadon does, with soft specular highlights that shift naturally as the vase rotates during its fall.

The shallow depth-of-field execution deserves special mention. Background elements blur with a natural gradient, not the hard-edged mask you see in cheaper implementations. The marble table's golden edge trim stays crisp in the foreground while the room behind falls off convincingly.

Weakness: Fragments don't scatter far enough for a hard stone floor impact. Real porcelain hitting stone at that velocity would send shards several feet in all directions — here they cluster within a tight radius. There's no visible dust or ceramic powder, which the prompt specifically requested. The falling vase also lacks motion blur, creating a slight "floating" quality in mid-air frames.

Sora 2

▶️ Watch video

Dimension	Score	Notes
Image Quality	9.0/10	Higher resolution reveals more detail. Cross-section of broken ceramic (grey body under glaze) is impressive
Prompt Adherence	7.5/10	Main elements present. Also missing dust particles
Physics Realism	8.0/10	Fracture mechanics more convincing — uneven thickness, irregular break edges match brittle fracture behavior
Lighting	9.0/10	Warm light from right. Correct differentiation between glossy ceramic and matte stone surfaces

Standout: The fracture detail is superior. You can see the grey ceramic body (the bisque) beneath the glaze at break points — a subtle but physically accurate detail that most 3D renders don't even attempt. The neck staying intact while the body shatters matches real ceramic stress distribution: the neck is the thickest, most structurally reinforced part of a vase.

Fragment edges show irregular, conchoidal fracture patterns consistent with brittle material failure. Some pieces have thin edges where the glaze chipped away from the body, others show thicker cross-sections. This level of fracture variance is what separates "convincing" from "obviously CG."

Weakness: Despite the superior fracture physics, some fragments still exhibit a slight "hovering" quality — they decelerate too quickly after impact rather than bouncing and sliding on the stone. Dust particles are absent, same as Seedance. The fragment count is also lower than expected for a vase of this size hitting a hard surface.

Test 1 Verdict

Sora 2 wins on fracture detail and raw resolution. The higher pixel count and more convincing break physics make this a clear edge for static-heavy or close-up content.

Seedance 2.0 wins on motion smoothness. The 60fps frame rate makes the slow-motion fall visually smoother. If your use case is actual slow-motion video (ads, product demos), that frame rate matters.

Both models failed to generate floating dust particles in sunlight — a shared limitation of current AI video generation. Volumetric particle effects (dust, smoke, mist) remain a weak point across all diffusion-based video models, likely because training data rarely isolates these subtle atmospheric elements.

Score summary for Test 1:

Model	Image Quality	Prompt Adherence	Physics	Lighting	Average
Seedance 2.0	8.5	7.5	7.0	9.0	8.0
Sora 2	9.0	7.5	8.0	9.0	8.4

Sora 2 takes this round by a narrow margin, driven by superior fracture physics and resolution. But if your use case prioritizes smooth slow-motion playback over freeze-frame detail, the 60fps advantage tips back toward Seedance.

Test 2 — Dynamic Human Motion (Rooftop Breakdance)

Prompt:

A street dancer performs an explosive breakdance routine on a rain-soaked city rooftop at night. Neon lights from surrounding buildings reflect off the wet surface. Camera circles the dancer in a dynamic 360-degree orbit. The dancer transitions from a power move into a freeze pose. Dramatic rim lighting, cinematic color grading with teal and orange tones

Seedance 2.0

▶️ Watch video

Dimension	Score	Notes
Image Quality	9.0/10	Stunning night rendering. Neon reflections on wet surfaces are almost photographic
Anatomy Accuracy	8.5/10	B-boy floor work poses are recognizable. Wrist-forearm-shoulder force lines align correctly
Motion Dynamics	9.0/10	Motion blur direction matches movement. Low center of gravity fits breakdance mechanics. 60fps keeps fast transitions smooth
Lighting & Atmosphere	9.5/10	Near-perfect neon reflections on wet ground. Rim lighting + backlit silhouette creates cinematic drama

Standout: This is where Seedance 2.0 truly shines. The teal-and-orange color grading is executed precisely. Neon reflections on the rain-soaked rooftop are stunning — red and cyan complementary colors map naturally onto the wet surface. The atmosphere is immersive enough for a professional music video.

The 60fps advantage is decisive here. Fast arm sweeps, power moves, and transitions look fluid rather than stuttery. Clothing has weight and drapes correctly during motion — the hoodie fabric stretches and bunches at the shoulders in ways that suggest real textile physics.

The color grading deserves a closer look. Teal and orange are complementary colors, and the prompt specifically requested this combination. Seedance didn't just tint the image — it placed warm orange neon sources behind the dancer (creating rim light) and cool cyan sources in front, then let the wet rooftop surface mix both colors in reflections. This is how a cinematographer would actually light this scene.

Water behavior on the rooftop is also convincing. The surface has a thin, even layer of water that reflects the cityscape above. When the dancer moves, you can see subtle disturbance patterns radiating outward from points of contact. It's not perfect fluid simulation, but it reads as "wet ground" instantly.

Sora 2

▶️ Watch video

Dimension	Score	Notes
Image Quality	8.0/10	Strong cyberpunk aesthetic, detailed city background. But has an "AI sheen" — everything looks too perfectly graded
Anatomy Accuracy	6.5/10	⚠️ Major weakness. Hand-ground contact is blurry, fingers indistinguishable. Torso narrows unnaturally during handstand. Feet/shoe edges have a "melting" quality
Motion Dynamics	8.0/10	Water splash effects are good, rotational momentum is credible. But some water droplets look more like noise than real droplets
Lighting & Atmosphere	8.5/10	Dual-source contrast (warm orange backlight + cool cyan front) handled well. But immersion falls short of Seedance

The anatomy problem is serious. During freeze poses and handstands, the dancer's hands dissolve into the ground contact surface — individual fingers are indistinguishable. The torso becomes tube-like rather than showing realistic ribcage-to-pelvis structure, losing the natural width variation between chest, waist, and hips. A second arm disappears entirely in some frames, creating an anatomical gap that breaks the illusion.

Foot and shoe edges exhibit a "melting" quality, where the boundary between footwear and air becomes soft and undefined. This is a common failure mode in diffusion-based video models when limbs overlap or contact surfaces.

It looks fine while playing at normal speed. Pause any frame during a freeze pose and things fall apart. For content that will only be viewed as video (social media, ads), this may be acceptable. For anything that might be screenshotted, thumbnailed, or analyzed, it's a dealbreaker.

Test 2 Verdict

Seedance 2.0 wins decisively. The anatomy accuracy gap (8.5 vs 6.5) is the largest single-dimension difference across all three tests. For any content involving dynamic human movement — dance, sports, action sequences — Seedance is the more reliable choice right now.

The 60fps frame rate compounds this advantage. At 30fps, fast breakdance movements produce noticeable judder. At 60fps, they're smooth.

If you're building a product that generates human-motion content through an AI video API, this result should heavily influence your model selection.

Score summary for Test 2:

Model	Image Quality	Anatomy	Motion	Lighting	Average
Seedance 2.0	9.0	8.5	9.0	9.5	9.0
Sora 2	8.0	6.5	8.0	8.5	7.75

This is the widest gap across all three tests. Seedance outperforms in every single dimension. The anatomy accuracy delta (8.5 vs 6.5) alone should be disqualifying for Sora in human-motion applications where frame-level quality matters.

For developers working on fitness apps, dance content platforms, sports highlights, or any product featuring dynamic human movement, this test provides strong evidence for defaulting to Seedance 2.0.

Test 3 — Facial Expression & Lighting (Elder Bookshop)

Prompt:

A wise elderly woman with silver hair and round spectacles sits in a cluttered antique bookshop. She picks up a leather-bound book, opens it, and her expression shifts from curiosity to wonder as golden light emanates from the pages. The light illuminates her face and the surrounding book spines. Camera slowly pushes in from medium shot to close-up on her face. Warm tungsten lighting mixed with the magical golden glow.

Seedance 2.0

▶️ Watch video

Dimension	Score	Notes
Facial Quality	8.5/10	Wrinkles, crow's feet, nasolabial folds render naturally. Round spectacles sit correctly on nose bridge with subtle refraction
Expression Transition	8.5/10	Quiet focus → wonder is conveyed through widening eyes, slightly raised brows, parting lips. Layered micro-expressions
Environment Detail	9.0/10	⭐ Richest scene of all tests. Floor-to-ceiling leather book spines, rolling library ladder, globe desk lamp, ink bottles, brass instruments
Golden Light Effect	9.0/10	Volumetric golden light radiates upward from pages. Correctly illuminates chin, cheeks, under-nose. Blends naturally with existing warm tungsten

Standout: The bookshop environment is extraordinary. It feels like a real, lived-in space — books stacked chaotically on floors and tables, period-appropriate props scattered naturally. The scene evokes a Dickensian bookshop or an Oxford study. Seedance built the entire world around the character, not just the character.

The golden light has actual volume. It interacts correctly with silver hair edges and fabric folds, creating natural rim highlights. The light doesn't just illuminate the face — it casts subtle warm reflections on the nearest book spines and creates a gentle glow on the table surface. This kind of multi-surface light interaction is what sells the "magical" quality of the scene.

The expression transition is worth examining in detail. It's not a simple cut from "neutral" to "amazed." You can see a sequence: concentration as she opens the book → slight confusion as the light first appears → recognition → genuine wonder with slightly parted lips and widened eyes. This micro-expression layering is what separates AI-generated faces that feel "alive" from those that feel "posed."

Sora 2

▶️ Watch video

Dimension	Score	Notes
Facial Quality	7.5/10	Passable but "waxy." Forehead and cheeks are too smooth. Aging inconsistent — some areas look 70+, others 50
Expression Transition	8.0/10	Wonder comes through (mouth opens, eyes widen). But eyelid and brow expressiveness is less nuanced than Seedance
Environment Detail	8.5/10	Good atmosphere with green banker's lamp. Depth of field handled well. But less layered — missing ladder, floor books, desk props
Golden Light Effect	9.0/10	Upward lighting direction correct. Golden particle effects add magical feel. Good subsurface scattering on skin

The "wax face" problem: Sora 2 renders elderly skin that's simultaneously wrinkled and oddly smooth. The forehead lacks the texture density you'd expect — age spots, pore visibility, and the slight translucency of thin elderly skin are all muted. Some areas of the face read as 70+ years old (around the eyes), while others look closer to 50 (forehead, cheeks). This inconsistency breaks the uncanny valley in close-up shots — exactly the shot this prompt calls for.

The bookshop environment, while atmospheric, is less layered than Seedance's version. It has a green banker's lamp and well-handled depth of field, but lacks the rolling ladder, floor-level book stacks, brass instruments, ink bottles, and other period props that make Seedance's version feel like a real space rather than a set.

Test 3 Verdict

Seedance 2.0 wins on facial detail and environmental richness. For character-driven content — storytelling, narrative ads, emotional close-ups — Seedance produces more believable faces and richer worlds.

Both models nail the golden magical light effect. That's a tie.

Score summary for Test 3:

Model	Face Quality	Expression	Environment	Light Effect	Average
Seedance 2.0	8.5	8.5	9.0	9.0	8.75
Sora 2	7.5	8.0	8.5	9.0	8.25

Seedance wins this round through more convincing facial aging and a richer environment. The "wax face" issue with Sora is particularly problematic in close-up shots, which are exactly what this prompt demands with its "medium shot to close-up" camera push.

For narrative content, short films, character-driven ads, or any application where emotional authenticity matters, Seedance's facial rendering is a meaningful advantage.

For more on getting the best results from Seedance prompts, see our prompt engineering guide.

Technical Specs Comparison

Here's the full technical breakdown based on our actual output analysis:

Specification	Seedance 2.0	Sora 2
Resolution	1280×720 (720p)	1792×1024 (~1080p)
Pixels per frame	921,600	1,835,008 (~2×)
Frame rate	60fps	30fps
Total frames (15s)	900	450
Duration range	4–15s	Up to 20s
Codec	H.264	H.264
Audio	AAC 44.1kHz stereo	AAC 96kHz stereo
Audio generation	Built-in (voice, SFX, music)	Built-in
Aspect ratios	16:9, 9:16, 1:1, 4:3, 3:4, 21:9	16:9, 9:16, 1:1
Input modes	Text, image, video, audio → video	Text, image → video
Max input images	9	1
Max input videos	3	N/A
@-reference system	✅ (multimodal tags)	❌

Key takeaways:

Seedance's 60fps produces 2× more frames in the same duration, which is why motion looks smoother
Sora's higher resolution is better for content that will be paused or screenshotted
Seedance's multimodal @-reference system allows combining image, video, and audio inputs in a single prompt — a capability Sora 2 doesn't offer
Seedance supports 1080p output as well (see API parameters below), though our tests used the default 720p

API Access & Code Examples

Both models are accessible via REST APIs. Here's how to call each one.

Seedance 2.0 via EvoLink API

EvoLink provides unified API access to Seedance 2.0 with async task processing. Here's a complete Python example:

import requests
import time

API_KEY = "your-evolink-api-key"  # Get one at evolink.ai/dashboard/keys
BASE_URL = "https://api.evolink.ai/v1"

def generate_video(prompt: str, duration: int = 15, quality: str = "720p") -> str:
    """Generate a video with Seedance 2.0 and return the video URL."""

    # Step 1: Submit generation task
    response = requests.post(
        f"{BASE_URL}/video/generations",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "model": "seedance-2.0",
            "prompt": prompt,
            "duration": duration,
            "quality": quality,
            "aspect_ratio": "16:9",
            "generate_audio": True,
        },
    )
    response.raise_for_status()
    task_id = response.json()["task_id"]
    print(f"Task submitted: {task_id}")

    # Step 2: Poll for completion
    while True:
        status_resp = requests.get(
            f"{BASE_URL}/tasks/{task_id}",
            headers={"Authorization": f"Bearer {API_KEY}"},
        )
        status_resp.raise_for_status()
        task = status_resp.json()

        if task["status"] == "completed":
            video_url = task["output"]["video_url"]
            print(f"Done! Video URL (valid 24h): {video_url}")
            return video_url
        elif task["status"] == "failed":
            raise RuntimeError(f"Task failed: {task.get('error', 'Unknown error')}")

        print(f"Status: {task['status']}... waiting 5s")
        time.sleep(5)


# Run the porcelain vase test
video = generate_video(
    prompt=(
        "A porcelain vase falls from a marble table in slow motion. "
        "Camera starts with a close-up of the vase wobbling on the edge, "
        "then follows it downward with a smooth tracking shot as it shatters "
        "on a stone floor. Fragments scatter in all directions. "
        "Dust particles float in warm afternoon sunlight streaming through a window. "
        "Shallow depth of field, 24fps cinematic look"
    ),
    duration=15,
    quality="720p",
)

Multimodal input example — using an image as the first frame:

response = requests.post(
    f"{BASE_URL}/video/generations",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "model": "seedance-2.0",
        "prompt": "@Image1 as first frame, the vase begins to wobble and fall",
        "image_urls": ["https://example.com/porcelain-vase.jpg"],
        "duration": 10,
        "quality": "1080p",
    },
)

For advanced multimodal workflows with @Image, @Video, and @Audio references, see our @Tags guide.

Sora 2 via OpenAI API

from openai import OpenAI

client = OpenAI()  # Uses OPENAI_API_KEY env var

# Submit video generation
response = client.responses.create(
    model="sora",
    input=[{
        "type": "text",
        "text": (
            "A porcelain vase falls from a marble table in slow motion. "
            "Camera starts with a close-up of the vase wobbling on the edge, "
            "then follows it downward with a smooth tracking shot as it shatters "
            "on a stone floor. Fragments scatter in all directions. "
            "Dust particles float in warm afternoon sunlight streaming through a window. "
            "Shallow depth of field, 24fps cinematic look"
        ),
    }],
    resolution="1080p",
    duration=15,
)

# Get the video URL from the response
video_url = response.output[0].url
print(f"Video URL: {video_url}")

Both APIs follow a similar pattern: submit a prompt, get back a video. But the differences go beyond just the endpoint.

Async vs sync: The EvoLink API for Seedance is asynchronous — you submit a task and poll for completion (or use a webhook callback). Sora via OpenAI returns directly. For production pipelines processing many videos, the async pattern is often preferable since you can submit batches without blocking.

Input flexibility: Seedance's @-reference system lets you combine up to 9 images, 3 videos, and 3 audio tracks in a single prompt. You can say "@Image1 as first frame, replicate @Video1 camera movement, sync to @Audio1 beat." Sora 2 supports image input but doesn't offer this kind of multimodal composition.

Output options: Seedance lets you toggle audio generation on or off per request, choose from six aspect ratios (including 21:9 ultrawide), and select 480p/720p/1080p resolution. Sora offers fewer output configuration options but delivers higher default resolution.

Video URL expiry: EvoLink video URLs expire after 24 hours — download or cache them immediately. Plan your pipeline accordingly.

Run this comparison yourself. Get your EvoLink API key and test with your own prompts. The code above works out of the box.

Pricing Breakdown

Cost per 15-second video at default settings, as of February 2026:

Sora 2 (via OpenAI / EvoLink)

Resolution	Duration	Price per video
720p	5s	$0.50
720p	10s	$1.00
720p	12s	$1.20
720p	20s	$2.00

That works out to $0.10/second at 720p standard tier. Our 15-second test videos cost approximately $1.50 each on Sora 2.

Source: seedance2api.app/pricing, as of Feb 2026

Seedance 2.0 (via EvoLink)

Pricing coming soon. Seedance 2.0 pricing will be announced at launch. The model supports 480p, 720p, and 1080p output with optional audio generation.

For context, here's how it stacks up against other models in the market:

Model	Cost per second	Est. cost per video	Max resolution
Seedance 2.0	Coming soon	Coming soon	1080p
Sora 2	$0.10 (720p)	$1.20 / 12s	720p (Std) / 1080p (Pro)
Kling 3.0	$0.112 (1080p)	$1.12 / 10s	4K
Veo 3.1	$0.40 (1080p)	$3.20 / 8s	4K

Source: seedance2api.app/pricing

Get early access to lock in launch pricing when it's announced.

Cost Considerations

Resolution tradeoff: Seedance at 720p costs less than Sora at 1080p, but delivers 60fps vs 30fps. Depending on your use case, the higher frame rate may be more valuable than the higher resolution.
Audio bundling: Both models can generate synchronized audio. Factor this into your per-video cost if you'd otherwise need separate audio generation.
Volume matters: For production workloads generating hundreds of videos, even small per-second differences compound. Test both with your actual prompts before committing.
Intellectual property: Seedance 2.0 outputs include commercial usage rights — verify the latest terms for your use case.
Hidden costs: Don't forget bandwidth, storage, and post-processing. Sora's higher resolution means larger file sizes (~2× per frame). If you're serving these videos to end users, CDN costs scale with file size. Seedance's 60fps means more frames per second but at lower resolution, resulting in comparable file sizes.
Free tier testing: Before committing to either API for production, run your actual prompts through both. The results from these three prompts may not generalize to your specific content domain. EvoLink offers a free API key to get started with Seedance testing.

When to Choose Which

Picking a model isn't about "which is better" — it's about matching capabilities to your specific use case.

Choose Seedance 2.0 when:

Dynamic human content — dance, sports, action, fitness. The anatomy accuracy gap (8.5 vs 6.5 in our test) is significant.
Slow-motion or high-motion content — 60fps makes a visible difference in ads, product demos, and cinematic sequences.
Character close-ups — facial detail and micro-expression rendering are more convincing, especially for elderly or highly detailed faces.
Multimodal workflows — you need to combine reference images, videos, and audio in a single generation using the @-reference system.
Rich environment scenes — Seedance builds more detailed, "lived-in" environments with more props and depth layers.
Flexible aspect ratios — 21:9 ultrawide and 4:3 formats aren't available on Sora.

Choose Sora 2 when:

Maximum resolution matters — if your output will be displayed at 1080p+ or screenshotted/paused frequently, Sora's higher pixel count wins.
Object destruction physics — fracture detail on breaking objects is more convincing (uneven thickness, visible internal material layers).
Static or slow-moving scenes — when the 60fps advantage doesn't apply, Sora's resolution advantage is uncontested.
Existing OpenAI integration — if your stack already uses the OpenAI SDK, adding Sora requires minimal new infrastructure.

The hybrid approach

For production pipelines, consider using both. Generate character/motion content with Seedance 2.0 and object/environment establishing shots with Sora 2. Both APIs follow standard REST patterns, making it straightforward to route prompts based on content type.

A simple routing heuristic based on our test results:

def choose_model(prompt: str, needs_pause_quality: bool = False) -> str:
    """Route to the better model based on content type."""
    motion_keywords = ["dance", "run", "fight", "sport", "action", "slow motion", "jump"]
    face_keywords = ["close-up", "expression", "portrait", "face", "emotion", "elderly"]

    prompt_lower = prompt.lower()

    if any(kw in prompt_lower for kw in motion_keywords):
        return "seedance-2.0"  # Better anatomy + 60fps
    if any(kw in prompt_lower for kw in face_keywords):
        return "seedance-2.0"  # Better facial detail
    if needs_pause_quality:
        return "sora"          # Higher resolution for screenshots
    return "seedance-2.0"      # Default to higher overall score

This is intentionally simplistic — your production router would use more sophisticated classification. But the principle holds: match the model to the content's primary requirement.

What about other models?

This comparison focused exclusively on Seedance 2.0 and Sora 2 because they represent the current production-grade tier of AI video APIs. Other models like Runway Gen-3, Pika, and Kling are viable alternatives but weren't included in this specific test. We may cover broader comparisons in future articles.

FAQ

Is Seedance 2.0 better than Sora 2?

In our tests, Seedance 2.0 scored higher overall (8.5 vs 8.0), with particular strengths in human anatomy accuracy, motion fluidity (60fps), lighting, and facial detail. Sora 2 wins on resolution and object fracture physics. Neither is universally "better" — it depends on your content type.

Can I access Seedance 2.0 through an API?

Yes. Seedance 2.0 is available through the EvoLink API with standard REST endpoints. It supports text-to-video, image-to-video, and video-to-video generation. Get an API key here.

What's the actual output quality difference at 720p?

At matched 720p resolution, Seedance delivers 60fps while Sora delivers 30fps. This means Seedance produces twice as many frames per second, resulting in noticeably smoother motion — especially in fast-moving scenes. For static content, the visual quality is comparable at the same resolution.

Do both models generate audio?

Yes. Both Seedance 2.0 and Sora 2 can generate synchronized audio including voice, sound effects, and background music. Seedance allows you to control audio generation with a generate_audio parameter and can align output to reference audio tracks via the @Audio tag.

Which model is more cost-effective for production use?

It depends on volume and content type. Sora 2 standard tier costs $0.10/second for 720p — a 15-second video runs about $1.50. Seedance 2.0 pricing hasn't been announced yet (coming at launch). Check seedance2api.app/pricing for the latest. If your content is motion-heavy, Seedance's 60fps at 720p may deliver better perceived quality per dollar than Sora's 30fps at the same resolution.

Can I use Seedance 2.0 outputs commercially?

Seedance 2.0 outputs through the EvoLink API include commercial usage rights, but terms vary. Read our detailed copyright and licensing guide for the full breakdown of what's allowed, including monetization on YouTube, use in client work, and redistribution rights. Always verify the latest terms before production deployment.

Final Scores

Dimension	Seedance 2.0	Sora 2
Image Quality	8.7	8.3
Prompt Adherence	8.3	7.8
Physics/Anatomy Realism	8.0	7.3
Lighting	9.2	8.8
Motion Fluidity	8.5	7.8
Overall	8.5	8.0

Both models represent the state of the art in AI video generation as of early 2026. Neither can generate floating dust particles. Neither produces perfect hands every time. But for production API use, these results should guide your model selection based on what you're actually building.

For the latest on Seedance model capabilities, see the official ByteDance Seed research page. For Sora documentation and updates, refer to OpenAI's official platform docs.

Start building with Seedance 2.0. Get your free EvoLink API key and generate your first video in under a minute.

Seedance 2.0 Copyright Crisis: What Every API Developer Needs to Know

EvoLink — Mon, 23 Feb 2026 13:30:10 +0000

The much-anticipated Seedance 2.0 API launch — originally scheduled for February 24, 2026 — is on hold. Five major Hollywood studios have sent cease-and-desist letters to ByteDance, the Motion Picture Association (MPA) has called Seedance 2.0 a "machine built for systemic infringement," and developers building on this model now face real questions about timelines, legal risk, and commercial viability.

If you're integrating Seedance 2.0 into your video generation pipeline, this guide covers everything you need to know: the full copyright timeline, why Hollywood is targeting this model specifically, what the API delay means in practice, how to protect your commercial projects, safe prompt engineering strategies with code examples, and how to keep your pipeline running through a unified multi-model API while the situation resolves.

What Happened: The Seedance 2.0 Copyright Timeline

The Seedance 2.0 copyright crisis didn't happen overnight, but it escalated remarkably fast once it started. Within a single week in February 2026, ByteDance went from receiving informal complaints to facing coordinated legal action from every major Hollywood studio.

Here's the verified timeline based on reporting from major news outlets:

Week 1: The Backlash Builds (February 14–16)

February 15, 2026 — TechCrunch reports that Hollywood studios are "not happy" about Seedance 2.0's capabilities. The article details how the model can generate video content that closely resembles copyrighted films and television shows. At this point, the complaints are still informal — no legal action has been taken, but the tone is sharp.

The trigger was a wave of social media posts showing Seedance 2.0 generating scenes featuring recognizable Disney characters, Marvel superheroes, and sequences that clearly mimicked specific films. These demonstrations went viral, and Hollywood noticed.

February 16, 2026 — The story goes mainstream across multiple outlets. CNBC reports that ByteDance has acknowledged the concerns and pledged to add safeguards to Seedance 2.0. The most significant quote comes from MPA CEO Charles Rivkin, who describes the situation as "unauthorized use on a massive scale."

The same day, Al Jazeera covers ByteDance's public pledge to implement fixes. NBC News also reports on ByteDance's response. The company's statement is carefully worded — acknowledging the concerns without admitting fault, and promising "enhanced content protections" without specifying what those would be or when they'd arrive.

At this stage, many developers assumed this was a typical tech-industry controversy that would blow over with some PR management and minor product adjustments. It didn't.

Week 2: Coordinated Legal Action (February 20–22)

February 20, 2026 — The situation escalates from PR problem to legal crisis. Axios reports that five studios — Disney, Warner Bros. Discovery, Paramount, Netflix, and Sony — have each sent individual cease-and-desist letters to ByteDance. This is a critical detail: these aren't joint letters through the MPA (though that comes later). Each studio's legal team independently decided that Seedance 2.0 posed enough of a threat to warrant direct legal action.

The language in these letters, as reported by Copyright Lately, is unusually aggressive for initial C&D communications:

Disney called Seedance 2.0 a "virtual smash-and-grab" of copyrighted content — language that frames the issue not as an accident but as deliberate theft
Paramount stated that Seedance 2.0 outputs were "indistinguishable" from their copyrighted material — a legally significant claim that could support an infringement case
Warner Bros. Discovery, Netflix, and Sony each filed their own letters with similarly strong language

Community discussions on Reddit's r/comfyui (2/20) begin surfacing reports that the planned API launch has been delayed due to deepfake and copyright concerns. Developer forums light up with speculation about timelines and implications.

February 21, 2026 — The MPA formalizes the industry's position. The Hollywood Reporter and Variety both report that the MPA has sent its own cease-and-desist letter to ByteDance, calling Seedance 2.0 a tool for "systemic infringement." This is the industry's trade association — representing all five studios plus others — adding its institutional weight to the individual studio actions.

Hacker News discussions (2/21) confirm that the API launch has been officially postponed, with ByteDance reportedly adding "pre-release safeguards" before proceeding.

February 22, 2026 — The Decoder reports the MPA's full characterization of Seedance 2.0: a "machine built for systemic infringement." This phrase — carefully chosen by MPA lawyers — goes beyond claiming the tool can be used to infringe. It asserts the tool was designed to infringe, which has significant legal implications if the case goes to court.

The same day, Chosun (South Korea) reports that ByteDance has officially delayed the Seedance 2.0 API release over the copyright disputes. This is the first direct confirmation from an outlet with sources inside ByteDance that the API timeline has changed specifically because of the legal action — not just routine development delays.

Where Things Stand Now (February 23, 2026)

As of today:

Five individual C&D letters from Disney, WBD, Paramount, Netflix, and Sony
One institutional C&D letter from the MPA
API launch postponed from February 24 to an unspecified future date
ByteDance committed to safeguards but hasn't specified implementation details or a timeline
No lawsuits filed yet — but C&D letters are typically the precursor to litigation if demands aren't met

Key takeaway for developers: This isn't a minor PR issue that will resolve quickly. The coordinated nature of the legal response — five studios plus the MPA — means ByteDance faces enormous pressure to make meaningful changes before the API launches. Plan accordingly.

Why Hollywood Is Targeting Seedance 2.0 Specifically

Other AI video generation tools exist — Kling, Sora, Veo, Runway Gen-3, Pika — so why is Seedance 2.0 drawing this level of legal fire? The answer lies in a specific combination of capabilities, output quality, and missing safeguards that made it uniquely threatening to Hollywood's content.

The Training Data Question

The core allegation underlying all the C&D letters is that Seedance 2.0 was trained on copyrighted film and television content without authorization. This isn't unique to Seedance — nearly every large generative model faces similar questions — but the MPA's language suggests they believe ByteDance's training dataset drew particularly heavily on Hollywood content.

The phrase "unauthorized use on a massive scale" from MPA CEO Rivkin (CNBC, 2/16) implies the studios have evidence (or at least strong suspicion) about the composition of the training data. Disney's "smash-and-grab" characterization suggests they believe this was deliberate rather than incidental.

What makes the training data question particularly pointed for Seedance 2.0 is ByteDance's position as a Chinese technology company. ByteDance operates TikTok, which hosts billions of clips — many containing copyrighted content uploaded by users. The studios may suspect (though this hasn't been publicly confirmed) that Seedance 2.0's training data included TikTok's vast library of user-uploaded movie clips, TV segments, and music videos.

The Output Fidelity Problem

What separates Seedance 2.0 from earlier AI video tools is its output quality, particularly in areas that matter most to Hollywood. The model excels at precisely the capabilities that make copyright infringement easier:

Character consistency across shots. Seedance 2.0 maintains consistent character appearance throughout a video — same face, same clothing, same proportions. Earlier models often produced characters that shifted appearance between frames. This consistency means that if a user generates content featuring a copyrighted character, the character looks like that character throughout the entire video, not just in one frame.

Precise facial expression and emotion control. The model can generate nuanced emotional performances — a character transitioning from surprise to joy, or from calm to panic. This makes it possible to create new "performances" of copyrighted characters that feel authentic to their established personalities.

Cinematic camera work. Seedance 2.0 reproduces specific cinematographic techniques: Hitchcock zooms, tracking shots, crane movements, one-take sequences. These are the visual signatures of Hollywood filmmaking, and the model can replicate them with high fidelity.

Native audio generation. Unlike most competitors, Seedance 2.0 generates synchronized audio — dialogue, sound effects, and music — along with the video. This means generated content isn't just visual copies; it's complete audiovisual works that can include character voices.

Multimodal references. The @-reference system allows users to upload images, videos, and audio as creative references. A user could upload a still of a copyrighted character and a clip showing specific camera movements, and the model would combine both into new content. For more on this system, see our @Tags Multimodal Guide.

The Missing Guardrails

At launch, Seedance 2.0 reportedly had minimal content filtering. Users could generate videos featuring recognizable Disney characters, Marvel heroes, Star Wars scenes, and other protected IP without any system-level intervention. This stood in stark contrast to competitors:

Seedance 2.0 (at launch)

Copyright Filters: ❌
Character Blocking: ❌
Celebrity Detection: ❌
Watermark: ❌
Content Policy: Minimal

OpenAI Sora

Copyright Filters: ✅
Character Blocking: ✅
Celebrity Detection: ✅
Watermark: ✅
Content Policy: Strict

Google Veo 2

Copyright Filters: ✅
Character Blocking: ✅
Celebrity Detection: ✅
Watermark: ✅
Content Policy: Strict

Runway Gen-3

Copyright Filters: Partial
Character Blocking: Partial
Celebrity Detection: ❌
Watermark: ✅
Content Policy: Moderate

Kling

Copyright Filters: Partial
Character Blocking: ❌
Celebrity Detection: Partial
Watermark: ✅
Content Policy: Moderate

Pika

Copyright Filters: Partial
Character Blocking: ❌
Celebrity Detection: ❌
Watermark: ✅
Content Policy: Moderate

OpenAI and Google invested heavily in content safety systems before launching their video models. Sora has multiple layers of filtering: it blocks prompts referencing copyrighted characters by name, detects generated faces that resemble real public figures, applies visible and invisible watermarks, and has human review processes for edge cases.

ByteDance apparently prioritized capability over safety for Seedance 2.0's initial release — and the result was a model that could produce Hollywood-quality content from Hollywood's own IP, with nothing to stop it.

Why Other AI Video Tools Haven't Faced Similar Action

The simple answer: a combination of weaker output quality, stronger safety filters, and US-based legal presence that makes them easier to negotiate with.

Sora and Veo are both produced by US companies (OpenAI and Google) with established legal teams and existing relationships with content owners. These companies have proactively engaged with rights holders, implemented robust content filtering, and in some cases pursued licensing agreements.

Runway and Kling have faced some criticism but haven't reached the output fidelity threshold where Hollywood's lawyers considered them an existential threat. Seedance 2.0 crossed that threshold.

The combination of highest-in-class output fidelity, absent guardrails, and a parent company based outside US jurisdiction created the perfect storm for legal action.

The API Delay: What We Know

The Seedance 2.0 API was originally scheduled for public release on February 24, 2026. That date has been pushed back with no confirmed replacement.

What ByteDance Has Promised

In response to the legal pressure, ByteDance has committed to implementing several safeguards before the API launches. Based on reporting from CNBC (2/16), Hacker News (2/21), and Al Jazeera (2/16):

Face detection and blocking — Preventing generation of recognizable real people. This includes actors, public figures, and potentially any real individual whose face appears in the training data. The system would need to compare generated faces against a database of known individuals.
Copyrighted character interception — Blocking prompts that reference known IP. This means text-level filtering (catching "Spider-Man" or "Elsa") plus visual-level detection (catching uploaded reference images of copyrighted characters). Both are technically complex at scale.
Watermarking — Adding invisible watermarks to all generated content for provenance tracking. This allows rights holders to identify AI-generated content and trace it back to the platform and potentially the user who generated it.
Content similarity detection — Broader filtering to prevent generation of content that closely matches specific copyrighted works. This could involve comparing generated frames against a database of copyrighted content — computationally expensive but legally necessary.

The Implementation Challenge

These safeguards aren't trivial to build. Each one involves significant engineering:

Text-level filtering is the easiest — maintaining a blocklist of character names, franchise names, and trademark terms. But it's also the easiest to circumvent ("a mouse with round ears wearing red shorts").

Visual-level detection is harder. The system needs to recognize copyrighted characters even when described indirectly, and detect when generated output resembles specific copyrighted content. This requires training separate detection models on the copyrighted content itself — which raises its own licensing questions.

Face recognition for celebrity/actor blocking requires a comprehensive face database and real-time comparison during generation. This needs to handle multiple angles, lighting conditions, and artistic styles.

Watermarking that survives compression, cropping, and format conversion is an active research area. ByteDance needs watermarks that are imperceptible to viewers but robust enough to survive the processing that typical social media distribution involves.

The MPA isn't going to accept a checkbox exercise. These safeguards need to actually work, and verifying that takes time.

What This Means for Developers Right Now

If you've been building around the Seedance 2.0 API, the delay creates several immediate practical problems:

1. No confirmed launch date. ByteDance hasn't announced a new timeline. The safeguards need to satisfy legal teams at five major studios plus the MPA — that's not a quick process. Realistic estimates range from weeks to months, depending on how aggressive the safeguard requirements are.

2. API behavior will change. The addition of content filtering means new error codes, modified prompt handling, and rejected inputs that previously worked in the web interface. Prompts referencing specific visual styles that are too close to copyrighted material will likely fail. You'll need to handle these rejections gracefully in your code.

3. Pricing uncertainty. Content filtering infrastructure costs money — both the compute for real-time detection and the engineering to build and maintain it. It's plausible that per-generation costs increase to cover the additional overhead. ByteDance could also implement tiered pricing based on the level of content filtering applied.

4. Terms of service will tighten. Expect stricter usage policies, particularly around:

Commercial use of generated content
Liability for infringing outputs
Requirements for prompt documentation
Restrictions on certain categories of content generation
Indemnification clauses (or lack thereof)

5. Rate limits and review processes. For enterprise API users, ByteDance may implement additional review processes for high-volume accounts or certain categories of content.

6. Downstream platform risk. If you're building a product on top of Seedance 2.0 API and offering video generation to your own users, you inherit whatever liability gaps exist. Your users could generate infringing content through your platform, and you could face claims from rights holders.

For developers who need video generation capabilities today and can't wait for the Seedance delay to resolve, implementing multi-model failover is the pragmatic solution. We cover this in detail in the EvoLink integration section below.

What This Means for Your Commercial Projects

The central question every developer building on AI video generation is asking: Can I safely use Seedance 2.0 API-generated content in commercial products?

The honest answer: it depends entirely on what you generate and how you generate it. The risk isn't binary — it exists on a spectrum, and understanding where your specific use case falls on that spectrum is essential.

Two Distinct Layers of Copyright Risk

Copyright risk in AI-generated content exists on two separate legal dimensions. Conflating them leads to either excessive caution (avoiding the technology entirely) or dangerous complacency (assuming everything is fine). Neither serves you well.

Layer 1: Training Data Liability (Model-Level Risk)

This is the MPA's primary concern and the basis for the C&D letters. If Seedance 2.0 was trained on copyrighted content without licensing, ByteDance faces potential statutory damages. But the critical question for developers: does that liability extend downstream to API users?

As of February 2026, no US court has ruled that downstream users of an AI model are liable for the model's training data composition. The closest precedents come from the ongoing cases against Stability AI, Midjourney, and others — but these target the model creators, not the end users.

However, the legal landscape is evolving rapidly. If a court eventually establishes that AI-generated content derived from infringing training data is itself a derivative work, developers who commercialized that content could face retroactive claims. The probability is debatable; the potential impact is not.

Layer 2: Output Content Liability (User-Level Risk)

This is the more immediate and actionable risk for developers. Regardless of the training data question, if your Seedance-generated video:

Contains recognizable copyrighted characters (Mickey Mouse, Spider-Man, Darth Vader)
Closely replicates specific copyrighted scenes or sequences
Features recognizable real people without their consent
Reproduces trademarked logos, brand elements, or distinctive visual identities
Mimics a specific artist's or studio's protected visual style closely enough to cause confusion

...then you face direct copyright, trademark, or right-of-publicity liability. This risk exists regardless of the training data question and regardless of which AI model you use.

Risk Spectrum for Common Use Cases

Original product showcase video using your own product images

Risk Level: 🟢 Low
Key Factors: Your assets, generic description, no IP references

Marketing video with original characters and scenes

Risk Level: 🟢 Low
Key Factors: Original creative direction, no existing IP

Generic stock-style footage (nature, cityscapes, abstract)

Risk Level: 🟢 Low
Key Factors: No character or IP involvement

Video mimicking a specific film's visual style

Risk Level: 🟡 Medium
Key Factors: Style alone isn't copyrightable, but too-close replication is risky

Content featuring original characters that resemble copyrighted ones

Risk Level: 🟡 Medium
Key Factors: "Inspired by" vs. "substantially similar" — a gray area

Video featuring recognizable copyrighted characters

Risk Level: 🔴 High
Key Factors: Direct infringement regardless of tool used

Content featuring real celebrity likenesses

Risk Level: 🔴 High
Key Factors: Right of publicity violations

Replication of specific copyrighted scenes

Risk Level: 🔴 High
Key Factors: Direct copying of protectable expression

Enterprise Compliance Checklist

Before using any AI video generation tool for commercial content, work through this checklist:

[ ] Review the platform's Terms of Service — Specifically: who owns the output? What commercial rights are granted? What usage restrictions apply? Does the platform indemnify you against infringement claims?
[ ] Establish an internal AI usage policy — Document which types of content are approved for AI generation and which require human creation. Train your team on the policy.
[ ] Audit every prompt before submission — Do any reference specific copyrighted characters, real people, or trademarked properties? Implement prompt review for commercial projects.
[ ] Check output similarity before publishing — Does the generated content closely resemble any specific copyrighted work? Use reverse image/video search and human review.
[ ] Document your entire process — Keep records of prompts, parameters, creative intent, and the review steps taken. This establishes good faith if challenged.
[ ] Get legal review for high-stakes content — For advertising campaigns, branded entertainment, or content with wide distribution, have IP counsel review both the platform terms and your specific outputs.
[ ] Consider E&O insurance — Errors and omissions insurance that explicitly covers AI-generated content is increasingly available and, for commercial video production, increasingly necessary.
[ ] Monitor legal developments — Subscribe to AI copyright legal updates. The landscape is changing monthly. What's acceptable practice today may be litigated tomorrow.
[ ] Plan for content recall — If a legal ruling changes the risk calculus for content you've already published, have a process to identify and address affected assets.

Bottom line: Generic, original content generated from descriptive prompts — no character names, no brand references, no actor likenesses, no deliberate replication of specific works — carries the lowest risk. Content that intentionally or negligently replicates existing IP carries the highest risk, and using an API doesn't insulate you from that risk.

Safe Prompt Practices: Avoiding Copyright Triggers

Whether you're using Seedance 2.0, Sora, Veo, or any other AI video generation model, safe prompt practices protect your projects from copyright risk. The fundamental principle: describe what you want to create, not what you want to copy.

This section provides concrete, actionable guidelines with code examples you can use directly in your Seedance 2.0 API integration.

Prompt Patterns to Avoid

These patterns will likely trigger copyright filters (once implemented) and create legal risk regardless of filtering:

"Generate a video of Spider-Man swinging through New York"

Why It's Risky: Direct copyrighted character reference
Legal Exposure: Copyright infringement

"Create a scene that looks like it's from Frozen"

Why It's Risky: Deliberate replication of copyrighted work
Legal Exposure: Copyright infringement

"Make a video featuring someone who looks like Scarlett Johansson"

Why It's Risky: Personality rights violation
Legal Exposure: Right of publicity

"Replicate the opening sequence of Blade Runner 2049"

Why It's Risky: Direct scene copying
Legal Exposure: Copyright infringement

"A character that looks like Elsa with ice powers"

Why It's Risky: Indirect copyrighted character reference
Legal Exposure: Copyright infringement

"Generate a video with the Nike swoosh logo"

Why It's Risky: Trademark use
Legal Exposure: Trademark infringement

"A wizard school that looks like Hogwarts"

Why It's Risky: Trademarked setting replication
Legal Exposure: Trademark dilution

"An anime girl in the exact style of Studio Ghibli"

Why It's Risky: Studio style replication
Legal Exposure: Gray area, potentially risky

The indirect references are particularly dangerous because they might pass text-level filters while still producing infringing output. "A princess with platinum blonde hair, ice powers, and a blue dress" doesn't say "Elsa," but the output almost certainly looks like Elsa.

Prompt Patterns That Work Safely

These patterns generate compelling, original content without copyright entanglement:

"A superhero in an original red and gold suit flies over a futuristic city at sunset"

Why It Works: Original character, original setting

"Cinematic drone shot over a coastal city at golden hour, warm color palette, anamorphic lens"

Why It Works: Generic scene with cinematic technique description

"A young woman in a flowing blue dress walks through a sunlit Mediterranean village"

Why It Works: Original character, generic setting

"Product showcase: silver smartwatch rotating on marble surface, studio lighting"

Why It Works: Your own product, generic staging

"@Image1 as first frame, tracking shot following the subject through a forest"

Why It Works: Your own reference assets

"Anime-style warrior in ornate jade armor standing on a cliff overlooking a stormy sea"

Why It Works: Original character in a generic style category

"Pixar-quality 3D animation: a wise old cat in spectacles sits at a cafe table"

Why It Works: Style quality reference (not a specific Pixar property)

The Style vs. Character Distinction

This is a nuance that matters legally. You can generally reference:

Artistic styles broadly — "anime style," "Pixar-quality 3D," "oil painting aesthetic," "noir cinematography"
Cinematographic techniques — "Hitchcock zoom," "Steadicam tracking shot," "Dutch angle"
Genre conventions — "cyberpunk cityscape," "fantasy medieval village," "space opera"

You should not reference:

Specific works — "like the chase scene in The Dark Knight"
Specific characters — even indirectly described
Specific studios' proprietary styles — if the description is specific enough to identify the source

The line is blurry, and when in doubt, make it more generic.

Code Example: Safe vs. Dangerous Prompts in Practice

Here's the complete setup for all code examples in this guide, using the Seedance 2.0 API through EvoLink:

import requests
import time

API_KEY = "your-evolink-api-key"  # Get yours at evolink.ai/early-access
BASE_URL = "https://api.evolink.ai/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def generate_video(payload):
    """Submit a video generation task and poll until complete."""
    response = requests.post(
        f"{BASE_URL}/videos/generations",
        headers=HEADERS,
        json=payload
    )
    response.raise_for_status()
    task = response.json()
    task_id = task["id"]
    print(f"Task created: {task_id} (model: {task['model']})")

    # Poll for completion
    while True:
        status_resp = requests.get(
            f"{BASE_URL}/tasks/{task_id}",
            headers=HEADERS
        )
        status_resp.raise_for_status()
        result = status_resp.json()

        if result["status"] == "completed":
            video_url = result["task_info"]["video_url"]
            print(f"✅ Video ready: {video_url}")
            return result
        elif result["status"] == "failed":
            raise Exception(f"Task failed: {result.get('error', 'Unknown')}")

        print(f"⏳ Progress: {result.get('progress', 0)}%")
        time.sleep(10)

Now compare a dangerous prompt with its safe equivalent — both achieving a similar creative outcome:

# ❌ DANGEROUS — references copyrighted character and specific film
dangerous_payload = {
    "model": "seedance-2.0",
    "prompt": "Spider-Man swings between skyscrapers in New York City, "
              "wearing his classic red and blue suit. He shoots a web "
              "line and does a backflip, landing on a rooftop. "
              "Marvel cinematic style, dramatic lighting.",
    "duration": 10,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": True
}
# This will likely be rejected by copyright filters AND exposes you legally

# ✅ SAFE — original character, similar visual impact
safe_payload = {
    "model": "seedance-2.0",
    "prompt": "A masked vigilante in a sleek crimson and silver suit "
              "swings between futuristic skyscrapers using retractable "
              "grappling cables. Dynamic tracking shot follows the arc "
              "of movement as the figure performs an acrobatic flip "
              "mid-air and lands on a glass rooftop. Cinematic action "
              "sequence, golden hour lighting, anamorphic lens flare. "
              "The city below is a mix of neon signs and steam vents.",
    "duration": 10,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": True
}

result = generate_video(safe_payload)

The safe prompt produces equally compelling video — original character design, dynamic action, cinematic quality — without referencing any copyrighted property. The output is commercially usable because it's original creative expression.

Product and Brand Content: Using Your Own Assets Safely

For commercial product videos, the safest and most effective approach is referencing your own assets through the @Image and @Video reference tags. This produces content that's copyright-safe by design:

# ✅ Product showcase using your own brand assets
product_payload = {
    "model": "seedance-2.0",
    "prompt": "@Image1 as the hero product. Cinematic product reveal: "
              "camera orbits slowly around the product on a clean white "
              "marble surface. Soft studio lighting with a single dramatic "
              "key light creating elegant shadows. Shallow depth of field. "
              "Premium commercial photography aesthetic. Camera movement: "
              "smooth 180-degree orbit, then slow push-in to detail shot.",
    "image_urls": ["https://your-cdn.com/your-product-photo.jpg"],
    "duration": 8,
    "quality": "1080p",
    "aspect_ratio": "16:9",
    "generate_audio": False
}

Uses the same setup and polling function from the first example above.

For more prompt engineering techniques — including the shot-script format with time-based descriptions and advanced @-reference combinations — see our comprehensive Seedance 2.0 Prompt Guide.

Building a Prompt Safety Layer in Your Application

If you're building a product that lets your users generate video content, consider implementing a client-side prompt safety check before sending requests to the API:

import re

# Basic copyright safety check — extend as needed
BLOCKED_TERMS = {
    # Characters
    "spider-man", "spiderman", "batman", "superman", "iron man",
    "mickey mouse", "elsa", "buzz lightyear", "pikachu", "mario",
    "harry potter", "darth vader", "baby yoda", "grogu",
    # Franchises
    "marvel", "disney", "pixar movie", "star wars", "pokemon",
    "lord of the rings", "game of thrones", "hogwarts",
    # Studios (when used to replicate their specific works)
    "studio ghibli film", "dreamworks movie",
    # Brands
    "nike swoosh", "coca-cola", "apple logo",
}

BLOCKED_PATTERNS = [
    r"looks?\s+like\s+\w+\s+(from|in)\s+",  # "looks like X from Y"
    r"(scene|sequence)\s+(from|in)\s+[A-Z]",  # "scene from [Movie]"
    r"in\s+the\s+style\s+of\s+[A-Z]\w+\s+[A-Z]",  # "in the style of [Studio Name]"
]

def check_prompt_safety(prompt: str) -> dict:
    """Check a prompt for potential copyright issues."""
    prompt_lower = prompt.lower()
    issues = []

    for term in BLOCKED_TERMS:
        if term in prompt_lower:
            issues.append(f"Blocked term found: '{term}'")

    for pattern in BLOCKED_PATTERNS:
        if re.search(pattern, prompt, re.IGNORECASE):
            issues.append(f"Risky pattern detected: {pattern}")

    return {
        "safe": len(issues) == 0,
        "issues": issues,
        "recommendation": "Revise prompt to use original descriptions"
                          if issues else "Prompt appears safe"
    }

# Usage
result = check_prompt_safety(
    "A Spider-Man style hero swinging through New York"
)
print(result)
# {'safe': False, 'issues': ['Blocked term found: \'spider-man\''],
#  'recommendation': 'Revise prompt to use original descriptions'}

result = check_prompt_safety(
    "A masked hero in crimson armor swings between futuristic towers"
)
print(result)
# {'safe': True, 'issues': [], 'recommendation': 'Prompt appears safe'}

This is a basic starting point. A production system should use more sophisticated NLP-based detection, regularly updated blocklists, and human review for borderline cases.

How to Access Seedance 2.0 API Through EvoLink

⚠️ Important disclaimer: EvoLink is a unified API gateway for multiple video generation models. EvoLink does not serve as a compliance intermediary and makes no guarantees about the copyright status of any model's outputs. Copyright compliance is the developer's responsibility. EvoLink provides access and infrastructure — not legal protection.

With that clearly stated, here's what EvoLink offers developers working with Seedance 2.0.

API Integration: Ready Now, Live When ByteDance Opens

EvoLink has completed its Seedance 2.0 API adapter. The endpoint, parameters, and response format are finalized and documented. When ByteDance officially enables the API after implementing its copyright safeguards, your EvoLink integration goes live immediately — zero code changes needed.

The integration follows the EvoLink Seedance 2.0 Video Generation API specification:

# Text-to-video: Seedance 2.0 via EvoLink
text_to_video = {
    "model": "seedance-2.0",
    "prompt": "A wise old cat in round spectacles sits at a cozy cafe "
              "table, paws wrapped around a tiny porcelain cup. Steam "
              "curls upward. The cat speaks in a calm, measured tone. "
              "Warm afternoon light through the cafe window, Pixar-quality "
              "3D animation, warm color palette, expressive character acting.",
    "duration": 10,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": True
}

result = generate_video(text_to_video)

Uses the same setup and polling function from the first code example.

Full Multimodal Generation: Images + Videos + Audio

Seedance 2.0's standout feature is its multimodal @-reference system — the ability to combine image, video, and audio inputs as creative references within a single generation request. Through EvoLink, all input modalities are fully supported:

# Multimodal generation — character ref + camera ref + audio sync
multimodal_payload = {
    "model": "seedance-2.0",
    "prompt": "@Image1 as character reference — dancer in athletic wear. "
              "Reference @Video1 camera movement style: rhythmic push-pull "
              "pan and tilt movements. @Audio1 for BGM rhythm — align cuts "
              "and motion energy to the beat. The dancer performs energetically "
              "on a colorful LED-lit stage. Spotlights shift colors in sync "
              "with the rhythm. Smoke effects catch the colored lighting.",
    "image_urls": [
        "https://your-cdn.com/character-design.png"
    ],
    "video_urls": [
        "https://your-cdn.com/camera-reference.mp4"
    ],
    "audio_urls": [
        "https://your-cdn.com/background-track.mp3"
    ],
    "duration": 12,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": True
}

result = generate_video(multimodal_payload)

Uses the same setup and polling function from the first code example.

Complete API Parameter Reference

Here's the full parameter set supported through EvoLink for Seedance 2.0:

model

Type: string
Required: ✅
Description: "seedance-2.0"

prompt

Type: string
Required: ✅
Description: Up to 2000 tokens. Supports @Image1, @Video1, @Audio1 references

image_urls

Type: string[]
Required: —
Description: Up to 9 images, max 30MB each. Formats: jpeg, png, webp, bmp, tiff, gif

video_urls

Type: string[]
Required: —
Description: Up to 3 videos, total 2-15s, max 50MB each. Formats: mp4, mov

audio_urls

Type: string[]
Required: —
Description: Up to 3 audio tracks, total ≤15s, max 15MB each. Formats: mp3, wav

duration

Type: integer
Required: —
Description: 4-15 seconds (default: 5)

quality

Type: string
Required: —
Description: "480p", "720p" (default), "1080p"

aspect_ratio

Type: string
Required: —
Description: "16:9" (default), "9:16", "1:1", "4:3", "3:4", "21:9", "adaptive"

generate_audio

Type: boolean
Required: —
Description: Enable synchronized audio generation (default: true)

callback_url

Type: string
Required: —
Description: HTTPS webhook URL for task completion notification

Input limits: Maximum 12 files total across all modalities. Realistic human face uploads are automatically rejected. All URLs must be directly accessible by the server.

Task flow: The API returns a task ID immediately. Poll the task status endpoint or use the callback_url webhook to receive completion notifications. Generated video URLs are valid for 24 hours — download and store them promptly.

Multi-Model Failover: Keep Your Pipeline Running During the Delay

This is where EvoLink's unified API architecture delivers concrete value during the Seedance 2.0 copyright delay. Instead of building and maintaining separate integrations for each model, you implement automatic failover with a single code path:

# Multi-model failover — your pipeline never stops
MODEL_PRIORITY = [
    "seedance-2.0",  # Preferred: best multimodal capabilities
    "kling",          # Fallback 1: strong motion quality
    "veo-2",          # Fallback 2: high visual fidelity
    "sora",           # Fallback 3: robust safety, good adherence
]

def generate_with_failover(prompt, duration=10, quality="720p",
                           aspect_ratio="16:9", **kwargs):
    """Try models in priority order. First success wins."""
    errors = {}
    for model in MODEL_PRIORITY:
        try:
            payload = {
                "model": model,
                "prompt": prompt,
                "duration": duration,
                "quality": quality,
                "aspect_ratio": aspect_ratio,
                **kwargs
            }
            result = generate_video(payload)
            print(f"✅ Generated with: {model}")
            return result
        except Exception as e:
            errors[model] = str(e)
            print(f"⚠️ {model} unavailable: {e}")
            continue

    raise Exception(f"All models failed: {errors}")

# Your application code stays the same regardless of model availability
result = generate_with_failover(
    prompt="Cinematic drone shot over a mountain lake at sunrise. "
           "Mist rises from the water surface. Golden light breaks "
           "through clouds and reflects off the still water. "
           "Slow, majestic camera movement.",
    duration=10,
    quality="720p",
    aspect_ratio="16:9",
    generate_audio=True
)

Uses the same setup and polling function from the first code example.

While Seedance 2.0 remains delayed, your pipeline generates video through Kling, Veo, or Sora via the same EvoLink endpoint. The moment Seedance comes back online, it slots into the priority list — no migration, no code changes, no downtime.

This isn't just about the current delay. Model availability is inherently unpredictable — rate limits, maintenance windows, policy changes, and yes, legal actions can take any model offline at any time. Building model-agnostic from day one is a strategic decision that pays dividends every time the landscape shifts.

For the complete API documentation including task management, webhooks, error handling, and SDK examples in Python, Node.js, and cURL, see the EvoLink Video Generation Docs.

Frequently Asked Questions

Is Seedance 2.0 API still launching?

Yes, but the timeline is uncertain. ByteDance delayed the originally planned February 24, 2026 launch to implement copyright safeguards including face detection, copyrighted character blocking, and watermarking (Chosun, 2/22; Hacker News, 2/21). No replacement launch date has been announced publicly. The delay will last until ByteDance's safeguard implementation satisfies both its own legal team and, presumably, addresses the core concerns raised in the MPA's cease-and-desist letter. Realistic estimates range from weeks to months.

Can I use Seedance 2.0 for commercial projects?

It depends entirely on what you generate. Content created from original prompts describing original characters and scenes — without referencing copyrighted properties, real people, or trademarked brands — carries the lowest legal risk. Content that deliberately or negligently replicates existing IP carries significant risk, and this is true regardless of which AI model generates it. When the API launches, review Seedance 2.0's Terms of Service carefully for specific commercial use provisions, and consult intellectual property counsel for high-stakes or high-distribution commercial projects. See the compliance checklist above for a practical framework.

Will my existing Seedance videos be taken down?

There's no indication that ByteDance plans to retroactively remove content already generated through the Seedance 2.0 web interface. The MPA's cease-and-desist letters target ByteDance's practices as a platform — not individual users or their outputs. However, if you've generated and published content featuring recognizable copyrighted characters or real people, you could face separate takedown requests (DMCA notices or equivalent) from the rights holders directly. That risk exists regardless of the generation tool used.

How does EvoLink handle copyright compliance?

EvoLink is a unified API gateway — it provides access to multiple video generation models through a single integration point. EvoLink does not filter, moderate, or validate the copyright status of prompts or generated outputs. Copyright compliance is entirely the developer's responsibility. What EvoLink does provide is infrastructure flexibility: if one model's content policies, availability, or legal situation doesn't meet your needs, you can switch to another model through the same API without changing your code. This model diversity itself is a practical risk mitigation strategy — you're never dependent on a single model's availability or policy decisions.

What alternatives exist if the Seedance API stays delayed?

Through EvoLink's unified API, you can access several production-ready alternatives using the same integration code you'd use for Seedance:

*Kling*

Strengths: Strong motion quality, character consistency
Content Policy: Moderate filtering
Best For: Action, character animation

*Veo 2*

Strengths: High visual fidelity, Google's safety infrastructure
Content Policy: Strict filtering
Best For: Premium quality, brand-safe content

*Sora*

Strengths: Strong prompt adherence, OpenAI safety stack
Content Policy: Strict filtering
Best For: Narrative content, precise direction

*Runway Gen-3*

Strengths: Established ecosystem, good motion
Content Policy: Moderate filtering
Best For: General purpose, rapid iteration

Each model has different strengths, content policies, pricing, and availability. EvoLink's multi-model architecture lets you evaluate all of them without building separate integrations. The failover code example above shows how to automatically switch between models based on availability. See the Video Generation API docs for model-specific parameters and capability comparisons.

What Comes Next

The Seedance 2.0 copyright situation is actively evolving. The safeguards ByteDance implements will reshape what the API can and can't generate. The legal precedents being set in response to AI video generation will affect every platform in this space, not just Seedance.

For developers, the practical path forward is clear:

Build model-agnostic. Don't stake your production pipeline on a single model's availability or legal status. Use a unified API that lets you switch models without code changes.
Prompt safely. Original descriptions, original characters, your own reference assets. The content that's safest legally is also the content that's most commercially valuable — because it's yours.
Stay informed. The legal landscape around AI-generated content is changing monthly. Follow developments in the MPA v. ByteDance situation and the broader AI copyright cases working through courts.
Document everything. Keep records of your prompts, parameters, creative intent, and review processes. Good-faith compliance efforts matter if questions arise.
Don't panic. The sky isn't falling. AI video generation is a transformative capability, and the legal frameworks will evolve to accommodate it. Developers who build responsibly now will be well-positioned when the rules solidify.

We'll update this guide as the situation develops. Bookmark it, and check back when new developments emerge.

Last updated: February 23, 2026. This article will be updated as the Seedance 2.0 copyright situation develops.

How to Replicate Camera Movements with Seedance 2.0 API

EvoLink — Sun, 22 Feb 2026 11:38:28 +0000

Camera movement is what separates a flat, static video from something that feels cinematic. A dolly zoom creates tension. An orbital shot adds grandeur. A one-take tracking shot builds immersion.

Traditionally, achieving these requires expensive equipment — gimbals, cranes, drones, Steadicams. Seedance 2.0 eliminates the hardware. Upload a reference video with the camera movement you want, tag it with @Video, and the API generates new content replicating the exact camera language.

The Key Concept: Show, Don't Tell

Most AI video generators rely on text prompts for camera control — "dolly in" or "pan left." Results are inconsistent.

Seedance 2.0 takes a different approach: upload a video that demonstrates the movement. The model analyzes and reproduces:

Camera trajectory — tracking paths, orbital arcs, crane movements
Speed and acceleration — ease-in, ease-out, smooth glides
Focal behavior — rack focus timing, depth-of-field shifts
Compositional rhythm — how long each framing holds

Example: One-Take Tracking Shot

import requests
import time

API_KEY = "YOUR_EVOLINK_API_KEY"
BASE = "https://api.evolink.ai/v1"

response = requests.post(
    f"{BASE}/videos/generations",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "seedance-2-0-t2v",
        "prompt": "A continuous tracking shot following a woman walking through a neon-lit Tokyo alley at night. @Video1 for camera movement reference. Rain-slicked streets, reflections, shallow depth of field.",
        "video_urls": ["https://example.com/tracking-reference.mp4"],
        "duration": 10,
        "quality": "1080p"
    }
)

task = response.json()
print(f"Task ID: {task['id']}")

Example: Hitchcock Zoom (Dolly Zoom)

response = requests.post(
    f"{BASE}/videos/generations",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "seedance-2-0-t2v",
        "prompt": "A man standing alone in an endless hallway. @Video1 for camera movement reference. The background stretches away while his face stays the same size. Dramatic lighting.",
        "video_urls": ["https://example.com/dolly-zoom-ref.mp4"],
        "duration": 8,
        "quality": "1080p"
    }
)

Example: Orbital Camera (360° Shot)

response = requests.post(
    f"{BASE}/videos/generations",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "seedance-2-0-t2v",
        "prompt": "A glowing crystal sculpture on a marble pedestal. @Video1 for camera movement reference. The camera orbits 360 degrees. Volumetric light rays.",
        "video_urls": ["https://example.com/orbital-ref.mp4"],
        "duration": 10,
        "quality": "1080p"
    }
)

Why This Matters

No other AI video API offers reference-based camera control:

Sora 2: Text-only camera prompts
Kling 3.0: Basic camera keywords
Veo 3.1: Limited camera vocabulary

Seedance 2.0 lets you take a camera movement from any source — Hollywood film, drone footage, your own gimbal clip — and apply it to entirely new content.

Read the Full Tutorial

This overview covers the basics. The complete tutorial includes:

3 production-ready Python scripts with polling and error handling
Reference video selection tips
Multi-reference combinations (camera + character + audio)
Troubleshooting common issues

👉 Read the full camera movement tutorial

EvoLink — unified AI API access. One key for Seedance 2.0, Sora 2, Veo 3.1, and 40+ AI models.

Seedance 2.0 @Tags: How to Direct AI Videos with Multimodal References

EvoLink — Sun, 22 Feb 2026 11:01:30 +0000

Most AI video generators take a text prompt and give you whatever they feel like. Seedance 2.0 works differently — you upload images, videos, and audio files, then use @tags to tell the model exactly what each file should do.

Think of it like a film director's shot list. Each uploaded file gets a role:

@Image1 as the first frame — pins the opening visual
@Video1 for camera movement reference — copies the cinematography
@Audio1 as background music — sets the soundtrack and rhythm

You can combine up to 12 files (9 images + 3 videos + 3 audio) in a single generation.

The @Tag Syntax

The format is simple: @ + asset type + number.

Tag Type	Range	Example
@Image	1-9	@Image1, @Image2
@Video	1-3	@Video1
@Audio	1-3	@Audio1

Quick API Example

import requests

response = requests.post(
    "https://api.evolink.ai/v1/videos/generations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "seedance-2-0-t2v",
        "prompt": "A cinematic sunset over the ocean, @Image1 as first frame, @Audio1 as background music. Slow dolly forward with warm golden light.",
        "image_urls": ["https://example.com/sunset.jpg"],
        "audio_urls": ["https://example.com/ambient.mp3"],
        "duration": 10,
        "quality": "1080p"
    }
)

What Makes @Tags Different

No other AI video API offers this level of multimodal control:

Sora 2: Text + single image input only, no audio reference
Kling 3.0: Image-to-video but no @tag assignment system
Veo 3.1: Text-only prompts, generates its own audio

Seedance 2.0's @tag system lets you direct the generation rather than just describe it.

Read the Full Guide

This is a condensed overview. The complete guide covers all @tag types with real prompt examples, file allocation strategies, common mistakes, and multi-modal combination recipes.

👉 Read the full @Tags guide on seedance2api.app

EvoLink provides unified AI API access — one key for all major AI models including Seedance 2.0, Sora 2, Veo 3.1, and more.