Name: Seedance 1 Pro API: Text to Video and Image to Video
Brand: magicapi
SKU: api-magicapi-text-and-image-to-video-api-bytedance-seedance-1-pro
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Text-to-Video and Image-to-Video API (ByteDance Seedance 1 Pro)

## Overview
Seedance 1 Pro is ByteDance's video generation model for text-to-video and image-to-video.

Send a `prompt`, and optionally an `image` to use as the first frame and a `last_frame_image` to end on. Set the `duration` (2 to 12 seconds), `resolution` (480p, 720p or 1080p) and `aspect_ratio`. Each request returns the URL of one mp4 video.

## Features
- **Text to video**: describe the scene and camera movement in `prompt`.
- **Image to video**: pass `image` to start the video from that picture.
- **Last frame**: `last_frame_image` sets the final frame; it only works when `image` is also given.
- **Duration**: 2 to 12 seconds (default 5).
- **Resolution**: `480p`, `720p` or `1080p` (default).
- **Aspect ratios**: `16:9` (default), `4:3`, `1:1`, `3:4`, `9:16`, `21:9`, `9:21`. Ignored when an image is used.
- **Fixed camera**: `camera_fixed` keeps the camera position still.
- **Seed**: set `seed` for reproducible results. Frame rate is fixed at 24 fps.

## Use Cases
1. **Social and ad clips**: short vertical or widescreen videos from a written idea.
2. **Animating product shots and artwork**: start from an image and add motion.
3. **Storyboards and previews**: test a shot before filming or editing.
4. **Transitions between two frames**: a clip that moves from `image` to `last_frame_image`.

## Visual Examples
### Example Input
Prompt: "The sun rises slowly between tall buildings. [Ground-level follow shot] Bicycle tires roll over a dew-covered street at dawn. The cyclist passes through dappled light under a bridge as the entire city gradually wakes up."

Settings: 5 seconds, 1080p, 16:9, 24 fps, moving camera, no input image.

```json
{
  "fps": 24,
  "prompt": "The sun rises slowly between tall buildings. [Ground-level follow shot] Bicycle tires roll over a dew-covered street at dawn. The cyclist passes through dappled light under a bridge as the entire city gradually wakes up.",
  "duration": 5,
  "resolution": "1080p",
  "aspect_ratio": "16:9",
  "camera_fixed": false
}
```

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/seedance-1-pro-output-dbrz9qhk-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes | none |  | Text prompt for video generation |
| `image` | string (URL) | No | none |  | Image URL (jpeg, png, gif or webp) for image-to-video generation, used as the first frame |
| `last_frame_image` | string (URL) | No | none |  | Image URL (jpeg, png, gif or webp) for the last frame. Only works if a first frame image is given too. |
| `duration` | integer | No | `5` | `2` to `12` | Video duration in seconds |
| `resolution` | string | No | `1080p` | `480p`, `720p`, `1080p` | Video resolution |
| `aspect_ratio` | string | No | `16:9` | `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, `21:9`, `9:21` | Video aspect ratio. Ignored if an image is used. |
| `fps` | integer | No | `24` | `24` | Frame rate (frames per second) |
| `camera_fixed` | boolean | No | `false` |  | Whether to fix the camera position |
| `seed` | integer | No | none |  | Random seed. Set for reproducible generation |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.038 per API unit.
- **1 API unit = 1 second of output video at the base rate**, multiplied by the factor for the `resolution`. Each request is billed on the requested `duration`, rounded up to whole seconds.

| `resolution` | Factor | Price per second | 5-second video |
| --- | --- | --- | --- |
| `480p` | 1 | $0.038 | $0.19 |
| `720p` | 2 | $0.076 | $0.38 |
| `1080p` (default) | 5 | $0.19 | $0.95 |

- With the defaults (`duration` 5, `resolution` `1080p`) a request costs $0.95. A 12-second 1080p video costs $2.28.
- **Example cost**: the example asked for 5 seconds at 1080p: 5 x 5 = 25 API units = **$0.95**.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/text-and-image-to-video-api-bytedance-seedance-1-pro`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 2 seconds and an overall timeout of 900 seconds (15 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-and-image-to-video-api-bytedance-seedance-1-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "bytedance/seedance-1-pro",
    "input": {
      "fps": 24,
      "prompt": "The sun rises slowly between tall buildings. [Ground-level follow shot] Bicycle tires roll over a dew-covered street at dawn. The cyclist passes through dappled light under a bridge as the entire city gradually wakes up.",
      "duration": 5,
      "resolution": "1080p",
      "aspect_ratio": "16:9",
      "camera_fixed": false
    }
  }'
```

Response (201 Created):
```json
{
  "id": "dbrz9qhkqhrmw0d1c6qsvdjn5c",
  "version": "bytedance/seedance-1-pro",
  "status": "starting",
  "created_at": "2026-10-22T03:37:14.632Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-and-image-to-video-api-bytedance-seedance-1-pro/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "dbrz9qhkqhrmw0d1c6qsvdjn5c",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/seedance-1-pro-output-dbrz9qhk-api-market.mp4",
  "error": null,
  "created_at": "2026-10-22T03:37:14.632Z",
  "started_at": "2026-10-22T03:37:14.642Z",
  "completed_at": "2026-10-22T03:38:11.156Z"
}
```

`output` is a single URL string pointing to the generated mp4 video.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt`, a `duration` outside 2 to 12, or a `resolution` that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.
## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-and-image-to-video-api-bytedance-seedance-1-pro";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "bytedance/seedance-1-pro", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 900000;
  const pollInterval = 2000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 15 minutes");
}

createAndWaitForPrediction({
    "fps": 24,
    "prompt": "The sun rises slowly between tall buildings. [Ground-level follow shot] Bicycle tires roll over a dew-covered street at dawn. The cyclist passes through dappled light under a bridge as the entire city gradually wakes up.",
    "duration": 5,
    "resolution": "1080p",
    "aspect_ratio": "16:9",
    "camera_fixed": false
  }).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-and-image-to-video-api-bytedance-seedance-1-pro"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "bytedance/seedance-1-pro", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 900
    poll_interval = 2
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 15 minutes")


output = create_and_wait_for_prediction({
    "fps": 24,
    "prompt": "The sun rises slowly between tall buildings. [Ground-level follow shot] Bicycle tires roll over a dew-covered street at dawn. The cyclist passes through dappled light under a bridge as the entire city gradually wakes up.",
    "duration": 5,
    "resolution": "1080p",
    "aspect_ratio": "16:9",
    "camera_fixed": False
})
print(output)
```

## FAQ
- **How do I turn an image into a video?**
  - Pass the image URL in `image` and describe the motion in `prompt`. `aspect_ratio` is ignored when an image is used.
- **Can I set the last frame?**
  - Yes. Pass `last_frame_image` together with `image`; it does not work on its own.
- **How can I lower the cost?**
  - Use `480p` ($0.038 per second) or `720p` ($0.076 per second) instead of `1080p` ($0.19 per second), or a shorter `duration`.
- **How long can a video be?**
  - 2 to 12 seconds, set with `duration` (default 5). You are billed on the duration you request.
- **Can I change the frame rate?**
  - No. `fps` only accepts 24.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Seedance 1 Pro API by ByteDance: generate 2 to 12 second videos at 480p, 720p or 1080p from a text prompt or a first frame image. Pay per second of video.