Seedance 2.0 API: A Technical Guide to AI Video Generation with Pricing and Integration Examples

Beginners
1

This post covers the Seedance 2.0 API — a unified AI video generation interface from EvoLink.ai that exposes text-to-video, image-to-video, and reference-to-video capabilities through a single consistent API. The focus here is on technical integration patterns, model selection logic, and cost modeling — the parts that matter when you’re building a real system around this.

API Design: Unified Async Task Model

The central design of Seedance 2.0 is a unified async task pattern across all generation modes. Rather than separate endpoints with different request and response schemas, every generation request follows the same lifecycle:

  1. POST /v1/videos/generations — submit task, receive ID immediately

  2. GET /v1/tasks/{id} — poll for status and progress

  3. Download video from result URL once status == "completed"

  4. Optional: configure callback_url in step 1 to receive a push notification instead of polling

This design is well-suited for video generation workloads where latency is variable (seconds to minutes depending on duration, resolution, and server load). The async pattern lets client applications remain responsive while generation proceeds in the background.

Model Family

Six models across three generation paradigms:

Text-to-Video:
  seedance-2.0-text-to-video           (quality-optimized)
  seedance-2.0-fast-text-to-video      (speed-optimized)

Image-to-Video:
  seedance-2.0-image-to-video          (quality-optimized)
  seedance-2.0-fast-image-to-video     (speed-optimized, broader format support)

Reference-to-Video:
  seedance-2.0-reference-to-video      (quality-optimized)
  seedance-2.0-fast-reference-to-video (speed-optimized)

All six models share the same request/response format. Switching generation mode is a parameter change, not a code change — which simplifies abstraction layer design.

Generation Modes

Text-to-Video

Prompt-driven generation with no required reference inputs. Supports optional model_params.web_search (fast variant) for real-time context injection.

Prompt quality is the primary variable in output quality. The model responds well to specificity around:

  • Camera motion (pan, tilt, zoom, dolly, static)

  • Lighting conditions (time of day, quality, color temperature)

  • Subject motion and behavior

  • Depth of field and focus behavior

  • Mood and color grade

curl --request POST   --url https://api.evolink.ai/v1/videos/generations   --header 'Authorization: Bearer YOUR_API_KEY'   --header 'Content-Type: application/json'   --data '{
    "model": "seedance-2.0-text-to-video",
    "prompt": "A macro shot of a glass frog on a green leaf, focus shifting to its transparent body and visible beating heart",
    "duration": 8,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": true
  }'

Image-to-Video

Animates static images with two distinct behaviors based on input count:

  • Single image (image_urls with 1 URL): animates outward from the provided frame

  • Two images (image_urls with 2 URLs): interpolates a smooth transition from first to last frame

The fast variant supports a broader set of image formats than the standard model.

curl --request POST   --url https://api.evolink.ai/v1/videos/generations   --header 'Authorization: Bearer YOUR_API_KEY'   --header 'Content-Type: application/json'   --data '{
    "model": "seedance-2.0-image-to-video",
    "prompt": "The camera slowly pushes in as the still image comes alive",
    "image_urls": ["https://example.com/first-frame.jpg"],
    "duration": 5,
    "aspect_ratio": "adaptive"
  }'

Reference-to-Video

The highest-flexibility mode. Accepts multimodal reference inputs via image_urls, video_urls, and audio_urls. Use cases include:

  • Video extension (continue an existing clip)

  • Style transfer (inherit visual characteristics from a reference image)

  • Motion transfer (inherit camera or subject movement from a reference video)

  • Audio-guided generation (use a reference audio track to guide pacing and mood)

  • Complex multimodal compositions combining multiple reference types

curl --request POST   --url https://api.evolink.ai/v1/videos/generations   --header 'Authorization: Bearer YOUR_API_KEY'   --header 'Content-Type: application/json'   --data '{
    "model": "seedance-2.0-reference-to-video",
    "prompt": "Use video 1 camera movement throughout the clip and audio 1 as background music",
    "image_urls": ["https://example.com/ref1.jpg"],
    "video_urls": ["https://example.com/reference.mp4"],
    "audio_urls": ["https://example.com/bgm.mp3"],
    "duration": 10,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": true
  }'

Billing note: For reference-to-video, input reference video duration is included in the cost calculation (see Pricing section below).

Parameters Reference

Parameter Type Values Notes
model string six model IDs required
prompt string — applies to all models
duration integer 4–15 or -1 -1 = smart duration
quality string 480p, 720p affects cost
aspect_ratio string 16:9, 9:16, 1:1, 4:3, 3:4, 21:9, adaptive
generate_audio boolean — free, included
callback_url string HTTPS URL optional, recommended for production
image_urls array 1-2 URLs image-to-video and reference-to-video
video_urls array URLs reference-to-video only
audio_urls array URLs reference-to-video only

Pricing Model

Credit-based pricing with a deterministic formula.

Text-to-video and image-to-video:

cost = output_duration_seconds × resolution_price

Reference-to-video:

cost = (input_reference_video_seconds + output_duration_seconds) × resolution_price

Resolution pricing:

Resolution Credits/Second
480p 4.63
720p 10.00

Additional pricing:

  • Audio generation: free (no extra charge)

  • Web search (model_params.web_search): 0.04 credits per actual search call

  • Smart duration (-1): reserves 10 seconds upfront, settles to actual output length at completion

  • 1 credit = 10,000 UC

Cost calculation examples:

Scenario Calculation Cost
5s text-to-video at 720p 5 × 10.00 50 credits
10s text-to-video at 720p 10 × 10.00 100 credits
5s image-to-video at 480p 5 × 4.63 23.15 credits
3s ref input + 7s output at 720p 10 × 10.00 100 credits

Full pricing documentation: EvoLinkAI/Seedance-2.0-API/docs/pricing.md

Python Integration

import requests
import time

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

# Create task
create_resp = requests.post(
    "https://api.evolink.ai/v1/videos/generations",
    headers=headers,
    json={
        "model": "seedance-2.0-text-to-video",
        "prompt": "A cinematic drone shot above snowy mountains at sunrise",
        "duration": 5,
        "quality": "720p",
        "aspect_ratio": "16:9"
    }
).json()

task_id = create_resp["id"]

# Poll until complete
while True:
    task = requests.get(
        f"https://api.evolink.ai/v1/tasks/{task_id}",
        headers={"Authorization": "Bearer YOUR_API_KEY"}
    ).json()

    if task.get("status") == "completed":
        video_url = task["result"]["video_url"]
        print(f"Video ready: {video_url}")
        break
    elif task.get("status") == "failed":
        print(f"Failed: {task}")
        break

    print(f"Progress: {task['progress']}%")
    time.sleep(3)

JavaScript Integration

const createResp = await fetch("https://api.evolink.ai/v1/videos/generations", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EVOLINK_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "seedance-2.0-fast-text-to-video",
    prompt: "A neon-lit cyberpunk alley in the rain, cinematic camera movement",
    duration: 5,
    quality: "720p",
    aspect_ratio: "16:9",
    generate_audio: true
  })
});

const { id: taskId } = await createResp.json();

// Poll for completion
const poll = async (taskId) => {
  while (true) {
    const resp = await fetch(`https://api.evolink.ai/v1/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${process.env.EVOLINK_API_KEY}` }
    });
    const task = await resp.json();

    if (task.status === "completed") return task.result.video_url;
    if (task.status === "failed") throw new Error(JSON.stringify(task));

    await new Promise(r => setTimeout(r, 3000));
  }
};

const videoUrl = await poll(taskId);
console.log(videoUrl);

Operational Notes

URL expiry: Generated video URLs are valid for 24 hours. Implement download-and-store in your completion handler for any production system.

Standard vs fast: Fast models trade some output quality for significantly lower generation time. The practical recommendation: use fast models during development and for high-volume workloads; use standard models for final production output.

Smart duration: Setting duration to -1 enables content-aware duration selection. The API reserves 10 seconds of credits upfront and settles to actual output at completion.

Callback vs polling: For production systems with multiple concurrent generations, callback URLs are cleaner than polling. Configure callback_url in the initial request; the API POSTs the completed task payload to your endpoint.

Repository and Documentation

  • API documentation: docs.evolink.ai

  • GitHub repository (examples, guides): EvoLinkAI/Seedance-2.0-API

  • Text-to-video guide: docs/text-to-video.md

  • Image-to-video guide: docs/image-to-video.md

  • Reference-to-video guide: docs/reference-to-video.md

  • Pricing details: docs/pricing.md

  • OpenClaw integration: EvoLinkAI/seedance2-video-gen-skill-for-openclaw

1 Like