Seedance 2.0 API: Pricing, Access, and Example Code

Seedance 2.0 is a video-and-audio generation model from ByteDance: it turns text prompts into video, animates images with first- and last-frame control, and accepts multimodal reference material to keep characters, styles, and camera moves consistent across shots. If you want to call it programmatically, the currently documented route is OpenRouter's unified video API, which listed Seedance 2.0 at from $0.06726 per second of video when we checked on October 19, 2026. There's also a no-code path — more on that at the end.

This article covers what the model can actually do, how the API access path works, what a clip realistically costs, and a simple rule for deciding between the two.

What Seedance 2.0 can do

Seedance 2.0 is a video-and-audio generation model. Its documented input modes cover the three workflows most short-form creators and developers need:

• Text-to-video. Describe the shot; the model generates the clip.
• Image-to-video with first- and last-frame control. Provide a starting image (and optionally an ending frame) and the model animates between them — useful for animating a product photo or a keyframe sequence.
• Multimodal reference-to-video. Supply reference images (in AI Fruit's implementation, up to 9) and the model uses them as visual guidance rather than exact frames. OpenRouter's model page describes Seedance 2.0 as particularly strong at preserving character consistency, visual style, and camera movement from reference material — the property that matters most when you need the same character to survive more than one shot.

Output is flexible on the formats that matter for social video. In AI Fruit's implementation, Seedance 2.0 produces clips from 4 to 15 seconds (5 seconds by default) at 480p, 720p, 1080p, or 4K, in six aspect ratios from 9:16 vertical to 21:9 ultrawide, with audio generation on by default.

On quality: we haven't benchmarked the model ourselves, and you should treat any single score as one signal. For context, Artificial Analysis' arena (as reported by OpenRouter) placed Seedance 2.0's Dreamina-hosted 720p entry at an Elo of 1,339 — top 1% of its overall image-to-video arena at access time.

How to access Seedance 2.0 through an API

The documented self-serve route as of October 19, 2026 is OpenRouter, an API aggregator that exposes the model under the slug bytedance/seedance-2.0. You create an OpenRouter API key, then use its video generation endpoints — you don't need a separate ByteDance account or a region-specific SDK.

OpenRouter's video API is asynchronous, because video generation takes minutes, not seconds. The documented workflow has four steps:

1. Submit a generation request to POST https://openrouter.ai/api/v1/videos.
2. Receive a job ID and a polling_url immediately (HTTP 202).
3. Poll GET /api/v1/videos/{jobId} until the status is completed (or failed).
4. Download the video from the returned content URL.

The request parameters cover everything Seedance 2.0 needs: model, prompt, duration, resolution (480p through 4K), aspect_ratio, generate_audio, plus the two image modes described below. If you request a duration or resolution the model doesn't support, the API rejects the call with a 400 that lists the supported values — worth checking against the video models endpoint (GET /api/v1/videos/models) before you build UI around it. There's also a webhook option (callback_url) if you'd rather be notified than poll.

Source: OpenRouter video generation documentation, accessed October 19, 2026.

A minimal example: submit, poll, download

The following Python script is adapted from OpenRouter's documented video-generation sample, with the model set to Seedance 2.0 and a 720p, 5-second request. It's documentation-based — a working skeleton for your first call, not a tuned production client:

import requests
import time

API_KEY = "your-openrouter-key"

url = "https://openrouter.ai/api/v1/videos"
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

payload = {
    "model": "bytedance/seedance-2.0",
    "prompt": "A drone shot rising over a neon-lit fruit market at night, camera pulling back smoothly",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": True,
}

# 1. Submit the job (returns 202 with a polling URL)
job = requests.post(url, headers=headers, json=payload).json()
print("Job:", job["id"], "status:", job["status"])

# 2. Poll until the job finishes
polling_url = job["polling_url"]
while True:
    time.sleep(30)
    status = requests.get(polling_url, headers=headers).json()
    print("Status:", status["status"])
    if status["status"] == "completed":
        break
    if status["status"] == "failed":
        raise SystemExit(f"Generation failed: {status.get('error')}")

# 3. Download the video (unsigned URLs still need the API key)
video = requests.get(status["unsigned_urls"][0], headers=headers)
with open("output.mp4", "wb") as f:
    f.write(video.content)
print("Saved output.mp4")

Jobs move through pending, in_progress, completed, and failed states. Completed responses include unsigned_urls (which require your API key to fetch) and may include temporary signed URLs you can hand to a <video> tag or a download manager.

Image-to-video and reference-to-video payloads

Two request fields switch the model's input mode:

Image-to-video — provide frame_images with an explicit frame_type:

{
  "model": "bytedance/seedance-2.0",
  "prompt": "The character slowly turns as steam rises around her",
  "frame_images": [
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/first-frame.png" },
      "frame_type": "first_frame"
    }
  ],
  "resolution": "1080p"
}

Reference-to-video — provide input_references instead. These images act as style and subject guidance, not exact frames:

{
  "model": "bytedance/seedance-2.0",
  "prompt": "The same character ordering street food at a rainy night market",
  "input_references": [
    { "type": "image_url", "image_url": { "url": "https://example.com/character-ref.png" } }
  ],
  "resolution": "720p"
}

If both fields are present, OpenRouter's documentation says frame_images takes precedence and the request is treated as image-to-video. This is where Seedance 2.0's headline strength pays off: reference images are how you keep a character or visual style stable across a series of clips.

What Seedance 2.0 costs

OpenRouter prices Seedance 2.0 by tokens, and its model page documents the formula: tokens = (output height × width × duration × 24) / 1024, with the hosted provider ("Seed") listed at $7.00 per million tokens — about $0.1512 per second of 720p (1280×720) video with audio, at access time.

The arithmetic is worth doing once, because it tells you exactly where your money goes:

Request	Token math	Approx. cost
480p (16:9), 5 s	≈ 48,000 tokens	≈ $0.34
720p (1280×720), 5 s	≈ 108,000 tokens	≈ $0.76
1080p (1920×1080), 5 s	≈ 243,000 tokens	≈ $1.70

(These are straight applications of the documented formula and listed rate on October 19, 2026 — a cost estimate, not a quote.)

Three things follow from that table. First, resolution dominates: a 4K clip costs roughly four times its 1080p equivalent, so render 4K only when the deliverable needs it. Second, duration is linear — a 15-second clip costs three times a 5-second one. Third, pricing scales per model variant: OpenRouter also listed Seedance 2.0 Mini (480p/720p output) from $0.03363/s, Seedance 2.0 Fast (speed-optimized) from $0.04035/s, and Seedance 2.5 (longer clips, more reference inputs) from $0.1028/s — all accessed October 19, 2026, and all worth re-checking before you commit, because these prices move.

If you'd rather not do token math at all, AI Fruit prices the same model in credits per second, shown before you generate: 16 credits/s at 480p, 35 at 720p, 102 at 1080p, and 208 at 4K (checked October 19, 2026; credit packs are on the pricing page). For a deeper look at how Seedance 2.0 costs behave across a real production budget, see Seedance 2.0 Video Cost: Short Drama ROI.

Source: OpenRouter model page for bytedance/seedance-2.0, accessed October 19, 2026. Prices change; re-check before committing.

When the API is worth it — and when it isn't

The API earns its keep when generation is a product surface or a pipeline step: an app feature, a batch of variations, scheduled content, or anything that needs to run unattended. That's what the polling, webhooks, and per-second pricing are designed for.

The API is the wrong tool when your actual job is "I need this clip now." In that case you'd be maintaining an API key, polling infrastructure, and failure handling to get one file. AI Fruit's online generator runs Seedance 2.0 directly in the browser — prompt, image, or reference-image input, duration and resolution pickers, and the exact credit cost displayed before you spend anything. It's the same model, without the plumbing. You can also start from the model's own page at Seedance 2.0 on AI Fruit.

The short version

Seedance 2.0 does text-to-video, first/last-frame image-to-video, and reference-guided generation with native audio — at 4–15 seconds and up to 4K. Programmatic access is documented through OpenRouter's async video API at from $0.06726/second (October 19, 2026), with cost scaling on resolution × duration by a published token formula. Build against the API when generation is part of your product; when it's part of your afternoon, skip the code and generate Seedance 2.0 clips online in AI Fruit.