Seedance 2.0 Fast API: Budget Video Generation Endpoint

One HTTP request, one cinema-grade AI video clip, $1.94. That's the unit economics of building on top of the Seedance 2.0 Fast API. Dedicated endpoints for text-to-video and image-to-video, deterministic pricing, same quality engine as Seedance 2.0 standard, and a ~20% cost advantage that matters when you're running at scale.

Here's the full developer guide.

What The Fast API Is For

If you're building an app, tool, or service that generates video for users — social scheduler, marketing automation platform, e-commerce content engine, internal creative tool — the Seedance 2.0 Fast API is the cheapest cinema-grade endpoint you can build on in 2026.

Same visual quality as Seedance 2.0 standard. Lower per-second cost. Higher compute throughput. Built for integration into workflows that produce video at volume.

The typical target user is a developer or team that needs to generate video programmatically based on user input — not a single creator generating one clip at a time through the UI.

The Two Endpoints

Text-to-video endpoint:

POST https://seedance.it.com/api/v1/bytedance/seedance-2.0/fast/text-to-video

Generates a video from a text prompt. No source image required.

Image-to-video endpoint:

POST https://seedance.it.com/api/v1/bytedance/seedance-2.0/fast/image-to-video

Generates a video starting from an uploaded source image with a motion prompt.

Both endpoints accept similar request bodies and return the same response format. Pick based on whether you have a source image to animate.

Authentication

Every request needs an API key in the Authorization header. Generate a key from your Seedance dashboard.

Authorization: Bearer YOUR_API_KEY

Keys are tied to your account and draw from your credit balance. Rotate them as needed through the dashboard.

Request Format: Text-To-Video

POST /api/v1/bytedance/seedance-2.0/fast/text-to-video
{
  "prompt": "Slow dolly in on a ceramic coffee cup on a wooden cafe table, morning window light, shallow depth of field, cinematic 35mm film look",
  "duration": 5,
  "aspect_ratio": "16:9"
}

Parameters:

• prompt (required, string): The text prompt describing the desired video.
• duration (required, integer): Clip length in seconds. Range: 4-15.
• aspect_ratio (required, string): One of "16:9", "9:16", "1:1".

Request Format: Image-To-Video

POST /api/v1/bytedance/seedance-2.0/fast/image-to-video
{
  "image_url": "https://your-cdn.com/source-image.jpg",
  "prompt": "Slow push in with shallow depth of field, cinematic 35mm film look",
  "duration": 5,
  "aspect_ratio": "16:9"
}

Parameters:

• image_url (required, string): Publicly accessible URL of the source image. Supported formats: JPG, PNG, WebP.
• prompt (required, string): Motion prompt describing how to animate the image.
• duration (required, integer): Clip length in seconds. Range: 4-15.
• aspect_ratio (required, string): Should match the source image aspect ratio for best results.

Response Format

Both endpoints return an async job ID:

{
  "job_id": "sdf_2026_abc123xyz",
  "status": "queued",
  "estimated_seconds": 45,
  "cost_credits": 242
}

Poll the status endpoint until the job is complete:

GET /api/v1/jobs/sdf_2026_abc123xyz

A completed response:

{
  "job_id": "sdf_2026_abc123xyz",
  "status": "completed",
  "video_url": "https://cdn.seedance.it.com/output/sdf_2026_abc123xyz.mp4",
  "duration_seconds": 5,
  "resolution": "720p",
  "credits_consumed": 242
}

Download the video_url and you have your MP4.

Full Python Example

import requests
import time

API_KEY = "your_api_key_here"
BASE_URL = "https://seedance.it.com/api/v1"

def generate_fast_video(prompt, duration=5, aspect_ratio="16:9"):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    # Submit generation job
    response = requests.post(
        f"{BASE_URL}/bytedance/seedance-2.0/fast/text-to-video",
        headers=headers,
        json={
            "prompt": prompt,
            "duration": duration,
            "aspect_ratio": aspect_ratio
        }
    )
    job = response.json()
    job_id = job["job_id"]
    print(f"Job queued: {job_id}, estimated {job['estimated_seconds']}s")
    
    # Poll for completion
    while True:
        time.sleep(10)
        status = requests.get(
            f"{BASE_URL}/jobs/{job_id}",
            headers=headers
        ).json()
        
        if status["status"] == "completed":
            print(f"Complete: {status['video_url']}")
            return status["video_url"]
        elif status["status"] == "failed":
            raise Exception(f"Generation failed: {status.get('error')}")
        else:
            print(f"Status: {status['status']}")

# Usage
video_url = generate_fast_video(
    "Slow tracking shot of a golden retriever running through autumn leaves, golden hour, cinematic 35mm film look",
    duration=5,
    aspect_ratio="16:9"
)

Full JavaScript Example

const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://seedance.it.com/api/v1';

async function generateFastVideo(prompt, duration = 5, aspectRatio = '16:9') {
  const headers = {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  };

  // Submit generation job
  const submitRes = await fetch(
    `${BASE_URL}/bytedance/seedance-2.0/fast/text-to-video`,
    {
      method: 'POST',
      headers,
      body: JSON.stringify({ prompt, duration, aspect_ratio: aspectRatio })
    }
  );
  const job = await submitRes.json();
  console.log(`Job queued: ${job.job_id}`);

  // Poll for completion
  while (true) {
    await new Promise(r => setTimeout(r, 10000));
    const statusRes = await fetch(
      `${BASE_URL}/jobs/${job.job_id}`,
      { headers }
    );
    const status = await statusRes.json();

    if (status.status === 'completed') {
      return status.video_url;
    } else if (status.status === 'failed') {
      throw new Error(`Generation failed: ${status.error}`);
    }
  }
}

// Usage
const videoUrl = await generateFastVideo(
  'Slow dolly in on a matcha latte in a ceramic cup, morning window light, cinematic 35mm',
  5,
  '9:16'
);

Ready to build on the API? Get your API key →

Pricing Per API Call

Every API call deducts credits from your balance based on duration:

| Duration | Credits | Cost | |---|---|---| | 4 seconds | 194 | $1.94 | | 5 seconds | 242 | $2.42 | | 8 seconds | 387 | $3.87 | | 10 seconds | 484 | $4.84 | | 15 seconds | 726 | $7.26 |

Credits don't expire. Buy in bulk via the credit tiers for better per-call economics — the Enterprise tier drops effective cost by ~17%.

Rate Limits And Throughput

Seedance 2.0 Fast API allows concurrent job submissions within reasonable limits. Typical accounts can submit 5-10 jobs in parallel without hitting throttles. Enterprise tier accounts can request higher concurrency.

Individual generation jobs take 30-150 seconds depending on duration. With 5 concurrent jobs, you can effectively produce a clip every ~15-30 seconds of wall-clock time.

For bulk batch generation (50+ clips), submit in waves of 5-10, wait for completion, then submit the next wave. Don't flood the API with hundreds of simultaneous requests.

Error Handling

Common error responses:

400 Bad Request: Invalid parameters. Check duration range, aspect ratio values, prompt length.

401 Unauthorized: Missing or invalid API key.

402 Payment Required: Insufficient credits. Top up via the dashboard.

429 Too Many Requests: Rate limit exceeded. Back off and retry.

500 Internal Server Error: Temporary server issue. Retry with exponential backoff.

Build your integration to handle 429 and 500 gracefully with retry logic. A simple exponential backoff (1s, 2s, 4s, 8s) covers most transient failures.

Fast vs Standard In API Context

The choice between Fast and standard API endpoints is mostly economic:

• Use Fast for high-volume programmatic generation, cost-sensitive apps, and everything that isn't a hero clip.
• Use standard for flagship content where the small quality edge justifies the 20% cost premium.

Most apps default to Fast. The standard endpoint is typically reserved for "premium tier" features or specific user requests.

Endpoint URLs:

• Fast text: bytedance/seedance-2.0/fast/text-to-video
• Fast image: bytedance/seedance-2.0/fast/image-to-video
• Standard text: bytedance/seedance-2.0/text-to-video
• Standard image: bytedance/seedance-2.0/image-to-video

Webhook Support

For long-running jobs, polling is wasteful. Seedance 2.0 Fast API supports webhook callbacks — include a webhook_url in your request body and you'll receive a POST when the job completes:

POST /api/v1/bytedance/seedance-2.0/fast/text-to-video
{
  "prompt": "...",
  "duration": 5,
  "aspect_ratio": "16:9",
  "webhook_url": "https://your-app.com/api/seedance-callback"
}

Your webhook endpoint receives the same JSON payload the status endpoint would return on completion. Implement idempotency — webhooks can retry on failure.

Common Questions, Quick Answers

What's the max concurrent jobs I can submit? Typical accounts: 5-10. Enterprise: negotiable.

Do credits deduct on failed jobs? No. Failed jobs refund the credits automatically.

Can I cancel an in-progress job? Yes, via POST /api/v1/jobs/{job_id}/cancel. Refunds credits if canceled before completion.

What file format is the output? MP4, H.264 video, AAC audio, 720p resolution.

How long do output URLs remain valid? Output CDN URLs are valid for 7 days. Download and store them in your own system for long-term use.

Is there a sandbox/test mode? No dedicated sandbox. Use your free 50 signup credits to test. The $10 Starter tier is also a low-risk way to build against real endpoints.

Start Building On The Seedance 2.0 Fast API

The API is deliberately simple: two endpoints, deterministic pricing, async job model, and a quality ceiling that matches the flagship Seedance 2.0 tier. Build on it for social tools, marketing automation, creator platforms, e-commerce content engines, or internal creative apps. The unit economics finally make video generation feasible as a feature inside other products.

Ready to build? Get your API key →

Keep reading: Seedance 2.0 Fast complete guide • Seedance 2.0 Fast pricing • Seedance 2.0 Fast batch creation