Name: BytePlus Seedance – Text to Video | $0.01/call | API.market
Brand: byteplus
SKU: api-byteplus-seedance-text-to-video-pro-fast
Availability: InStock
Author: API Market

Pulkit

# 🎬BytePlus Seedance 1.0 Pro Fast - Text to Video API

## Overview

The BytePlus Seedance 1.0 Pro Fast Text-to-Video API allows you to generate high-quality videos from textual descriptions. Simply provide a text prompt and desired video parameters, and the API will return a URL to the generated video. This API utilizes the Seedance 1.0 Pro Fast model, offering a balance of speed and quality for your text-to-video generation needs.

## Features

* **Text-to-Video Generation:** Create videos from simple text prompts.
* **Resolution Control:** Choose from 480p, 720p, or 1080p resolutions.
* **Aspect Ratio Options:** Support for various aspect ratios including 21:9, 16:9, 4:3, 1:1, 3:4, 9:16, 9:21, and adaptive.
* **Duration Control:** Specify the video duration between 2 and 12 seconds.
* **Watermark Option:** Add or remove a watermark.
* **Seed Control:** Control the randomness of the generated video.
* **Camera Control:** Option to fix the camera.

## Use Cases

* **Marketing & Advertising:** Generate engaging video content for social media campaigns directly from text descriptions of product features or brand stories.
* **Content Creation:** Quickly create video clips for educational content, tutorials, or explainer videos based on scripts.
* **eLearning:** Automate the creation of video demonstrations for online courses, illustrating concepts with visually generated content.
* **Social Media Storytelling:** Let users generate short, engaging videos for platforms like TikTok or Instagram Reels from creative text prompts.
* **Real Estate Marketing:** Visualize property descriptions by automatically generating videos showcasing key features from textual descriptions.

## Visual Examples

**Example prompt:** "A busy city street during heavy rain at night, neon signs reflecting on wet roads, people walking with umbrellas, cars passing by, cinematic lighting, realistic rain effects, atmospheric mood"

**Parameters:** 720p, 16:9, 5 seconds

**Example output video:**

![Seedance 1.0 Pro Fast – city street rain (720p, 5s)](https://blog.api.market/wp-content/uploads/2026/02/seedance-1.0-fast.mp4)

The API returns a video URL in `output.video_url` when the job status is `succeeded`.

### Pricing 

#### 1. Pricing Table (at $0.01/unit)

| Resolution | Multiplier (Units/sec) | Cost per Second | Example (5s Video) |
| :--- | :--- | :--- | :--- |
| **480p** | **1.0** | $0.010 | **$0.05** |
| **720p** | **2.1** | $0.021 | **$0.105** |
| **1080p** | **5.0** | $0.050 | **$0.25** |

---


## API Documentation

### Base URL

```
https://prod.api.market/api/v1/byteplus/seedance-text-to-video-pro-fast
```

### Authentication

Authentication is handled via API key. Include your API key in the request header:

```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing

**IMPORTANT:** This API uses asynchronous processing for video generation. The typical flow is:

1. Submit a generation request to the `/text-to-video-pro-fast/run` endpoint.
2. Receive a job ID in the response.
3. Poll the `/text-to-video-pro-fast/status/{job_id}` endpoint with the job ID to check the status.
4. Continue polling until the generation is complete.

Your code should implement:

* A polling interval of **2–3 seconds** between status checks.
* A maximum timeout of 600 seconds (10 minutes).
* Continue polling while status is `submitted`, `IN_QUEUE`, or `IN_PROGRESS`.
* Result handling when status becomes `succeeded` or `COMPLETED`.
* Error handling when status becomes `failed` or `FAILED`, or the timeout is reached.

See the Implementation Guide section for code examples.

### Endpoints

#### 1. Submit Text-to-Video Generation Job

`POST /text-to-video-pro-fast/run`

**Description:** Submits a text-to-video generation job.

**Request Body:**

```json
{
  "input": {
    "prompt": "A busy city street during heavy rain at night, neon signs reflecting on wet roads, people walking with umbrellas, cars passing by, cinematic lighting, realistic rain effects, atmospheric mood",
    "resolution": "720p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false,
    "seed": -1,
    "camerafixed": false
  }
}
```

**Parameters:**

| Parameter    | Type    | Required | Description |
|-------------|---------|----------|-------------|
| `prompt`    | string  | Yes      | The text prompt for video generation. |
| `resolution`| string  | Yes      | Video resolution: `480p`, `720p`, or `1080p`. |
| `ratio`     | string  | Yes      | Aspect ratio: `21:9`, `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, `9:21`, or `adaptive`. |
| `duration`  | integer | Yes      | Video duration in seconds (2–12). |
| `watermark` | boolean | No       | Whether to include a watermark. Default: `false`. |
| `seed`      | integer | No       | Seed for reproducibility (-1 for random). |
| `camerafixed` | boolean | No     | Whether to fix the camera. Default: `false`. |

**Request Headers:**

* `Content-Type: application/json`
* `x-api-market-key`: Your API.market API key.

**Response (Success - Job Submitted):**

```json
{
  "id": "cgt-20260217190122-htz5z",
  "status": "submitted"
}
```

**cURL Example:**

```bash
curl -X POST "https://prod.api.market/api/v1/byteplus/seedance-text-to-video-pro-fast/text-to-video-pro-fast/run" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "A busy city street during heavy rain at night, neon signs reflecting on wet roads, people walking with umbrellas, cars passing by, cinematic lighting, realistic rain effects, atmospheric mood",
      "resolution": "720p",
      "ratio": "16:9",
      "duration": 5,
      "watermark": false,
      "seed": -1,
      "camerafixed": false
    }
  }'
```

#### 2. Get Text-to-Video Job Status

`GET /text-to-video-pro-fast/status/{job_id}`

**Description:** Retrieves the status of a text-to-video generation job.

**Parameters:**

* `job_id` (string, required, path): The job identifier returned by the `run` endpoint.

**Request Headers:**

* `x-api-market-key`: Your API.market API key.

**Response (Job In Progress):**

```json
{
  "id": "cgt-20260217190122-htz5z",
  "status": "submitted"
}
```

**Response (Job Succeeded):**

```json
{
  "id": "cgt-20260217190122-htz5z",
  "status": "succeeded",
  "output": {
    "video_url": "https://ark-content-generation-ap-southeast-1.tos-ap-southeast-1.volces.com/seedance-1-0-pro-fast/example.mp4"
  },
  "usage": {
    "completion_tokens": 103818,
    "total_tokens": 103818
  },
  "created_at": 1771326082,
  "updated_at": 1771326105
}
```

**cURL Example:**

```bash
curl -X GET "https://prod.api.market/api/v1/byteplus/seedance-text-to-video-pro-fast/text-to-video-pro-fast/status/cgt-20260217190122-htz5z" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## Status Codes

* **200 OK:** Request successful.
* **400 Bad Request:** Invalid input parameters or malformed request.
* **401 Unauthorized:** Missing or invalid API key.
* **403 Forbidden:** Valid API key but insufficient permissions.
* **404 Not Found:** Resource not found (e.g. invalid job ID).
* **429 Too Many Requests:** Rate limit exceeded.
* **500 Internal Server Error:** Server-side error.
* **503 Service Unavailable:** Service temporarily unavailable.

## Rate Limits

Refer to your API.market account for the specific rate limits for your subscription. Exceeding the limit returns `429 Too Many Requests`. Implement retry logic with exponential backoff (e.g. 2s, 4s, 8s) when you receive 429 or 503.

## Error Handling

The API returns errors in JSON format:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'duration' must be between 2 and 12.",
    "status": 400
  }
}
```

**Common error codes:**

* `invalid_parameter`: One or more input parameters are invalid.
* `missing_parameter`: A required parameter is missing.
* `rate_limit_exceeded`: Rate limit exceeded; reduce request frequency.
* `server_error`: Unexpected server error; retry later.

For transient errors (503, 429), retry with exponential backoff.

## Implementation Guide

### JavaScript

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/byteplus/seedance-text-to-video-pro-fast";

async function createAndWaitForPrediction(inputData) {
  const response = await fetch(`${baseUrl}/text-to-video-pro-fast/run`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey,
    },
    body: JSON.stringify({ input: inputData }),
  });

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

  const prediction = await response.json();
  const predictionId = prediction.id;

  return pollForResults(predictionId);
}

function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 10 minutes
  const POLL_INTERVAL = 2000; // 2 seconds

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(
      `${baseUrl}/text-to-video-pro-fast/status/${predictionId}`,
      { headers: { "x-api-market-key": apiKey } }
    );

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

    const prediction = await response.json();

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

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

    await delay(POLL_INTERVAL);
  }

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

// Example usage
const inputData = {
  prompt: "A futuristic cityscape at sunset",
  resolution: "720p",
  ratio: "16:9",
  duration: 5,
  watermark: false,
  seed: -1,
  camerafixed: false,
};

createAndWaitForPrediction(inputData)
  .then((output) => console.log("Video URL:", output.video_url))
  .catch((err) => console.error("Error:", err));
```

### Python

```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/byteplus/seedance-text-to-video-pro-fast"

def create_and_wait_for_prediction(input_data):
    response = requests.post(
        f"{BASE_URL}/text-to-video-pro-fast/run",
        headers={"Content-Type": "application/json", "x-api-market-key": API_KEY},
        json={"input": input_data},
    )
    if response.status_code != 200:
        raise Exception(f"API error: {response.status_code} {response.text}")
    prediction_id = response.json()["id"]
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600
    POLL_INTERVAL = 2
    start = time.time()
    while time.time() - start < MAX_TIMEOUT:
        resp = requests.get(
            f"{BASE_URL}/text-to-video-pro-fast/status/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        resp.raise_for_status()
        data = resp.json()
        if data.get("status") in ("succeeded", "COMPLETED"):
            return data["output"]
        if data.get("status") in ("failed", "FAILED"):
            raise Exception(f"Prediction failed: {data.get('error', 'Unknown error')}")
        time.sleep(POLL_INTERVAL)
    raise Exception("Prediction timed out after 10 minutes")

# Example usage
input_data = {
    "prompt": "A futuristic cityscape at sunset",
    "resolution": "720p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": False,
    "seed": -1,
    "camerafixed": False,
}
output = create_and_wait_for_prediction(input_data)
print("Video URL:", output["video_url"])
```

### cURL

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/byteplus/seedance-text-to-video-pro-fast/text-to-video-pro-fast/run" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "A futuristic cityscape at sunset",
      "resolution": "720p",
      "ratio": "16:9",
      "duration": 5,
      "watermark": false,
      "seed": -1,
      "camerafixed": false
    }
  }'

# Response: {"id": "cgt-...", "status": "submitted"}

# Step 2: Poll status (replace {job_id} with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/byteplus/seedance-text-to-video-pro-fast/text-to-video-pro-fast/status/{job_id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Tips

* Use 480p for prototyping; switch to 720p or 1080p for final output.
* Shorter durations (2–5s) generate faster and cost fewer units.
* Use a fixed `seed` for reproducible results when iterating on prompts.

## FAQ

**Q: How long does it take to generate a video?**  
A: Typically under 5 minutes, depending on resolution and duration. Use the status endpoint to track progress; allow up to 10 minutes before timing out.

**Q: What happens if I exceed the rate limit?**  
A: You receive `429 Too Many Requests`. Reduce request frequency or upgrade your API.market plan.

**Q: How do I choose the right aspect ratio?**  
A: 16:9 for YouTube, 9:16 for TikTok/Reels, 1:1 for square posts. Use `adaptive` when the platform is flexible.

**Q: Can I use this API for commercial purposes?**  
A: Yes, subject to API.market and BytePlus terms of service.

## Contact Us

For questions or support, use the chat on the page or email **hello@api.market**.


Generate high-quality videos from simple text prompts. Up to 1080p resolution. From $0.01/call. Try it free on API.market.