> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.beatapi.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.beatapi.io/_mcp/server.

# Seedance 2

POST https://api.beatapi.io/v1/videos/tasks
Content-Type: application/json

Generate 4–15 second videos from text, first/last frames, or multimodal references, with optional generated audio.

### Supported modes

| Mode                  | Required input                             | Rules                                                         |
| --------------------- | ------------------------------------------ | ------------------------------------------------------------- |
| Text to video         | `model`, `prompt`                          | Omit all media arrays.                                        |
| First frame           | `model`, `prompt`, `images`                | Provide one image URL; provide two for first and last frames. |
| Multimodal references | `model`, `prompt`, one `reference_*` array | Audio references also require a reference image or video.     |

**Reference videos:** each second of `reference_videos` is billed at the same per-second rate as the output, for as long as the references run (15 seconds at most in total). Their length is read when the task is created and that is what is held; when it cannot be read, the 15-second maximum is held and the unused part is refunded when the task finishes. A request with a reference video is never billed below 1.5 times the price of the same output without one, which is what applies when the reference is much shorter than the output.

**Async flow:** Create the task, save `data.id`, then [poll the Task](/quick-guide#get-task-status) with `GET /v1/tasks/{task_id}`. On `succeeded`, read `data.output.media`. On `failed`, read `data.error_code` and `data.error_message`, then follow the [error and retry policy](/quick-guide#errors-and-retry-policy).

**Using a local file?** [upload a local input](/quick-guide#upload-an-input-file) first and pass the returned `data.url`.

Reference: https://docs.beatapi.io/api-reference/video-api/seedance-2

## Authentication

- `Authorization` header (bearer token, required) — Send your API key as `Authorization: Bearer <BEATAPI_API_KEY>`.

## Request

### Headers

- `Idempotency-Key` (string, optional)

### Body (application/json)

This endpoint expects a Seedance2VideoRequest.

- `model` ("seedance-2", required) — Must be `seedance-2`.
- `prompt` (string, required) — Video generation instructions.
- `images` (list of string, optional) — One first-frame image or first- and last-frame images as public HTTPS URLs.
- `reference_images` (list of string, optional) — Public HTTPS image references for multimodal reference generation.
- `reference_videos` (list of string, optional) — Public HTTPS video references for multimodal reference generation.
- `reference_audios` (list of string, optional) — Public HTTPS audio references. Audio also requires at least one reference image or video.
- `duration` (integer, optional, default: 5) — Requested output duration in seconds.
- `aspect_ratio` (enum, optional, default: adaptive) — Output video aspect ratio.
  - Allowed values: `adaptive`, `21:9`, `16:9`, `4:3`, `1:1`, `3:4`, `9:16`
- `resolution` (enum, optional, default: 720p) — Output resolution tier. 4k and 4K are equivalent. 1080p is not supported with reference images.
  - Allowed values: `480p`, `720p`, `1080p`, `4k`, `4K`
- `generate_audio` (boolean, optional, default: true) — Generate synchronized audio with the video.

## Response

### 201

Video generation task accepted

## Errors

### 400 Bad Request Error

Malformed JSON or a field, value or combination this endpoint does not accept (`bad_request`; the message names the field), or input refused by moderation (`content_policy_violation`). Not retryable unchanged.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 401 Unauthorized Error

No API key (`missing_api_key`), or a key that is wrong, expired, disabled or exhausted (`invalid_api_key`; the message says which). Send it as `Authorization: Bearer <key>`; the key works with or without the `sk-` prefix. Not retryable.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 402 Payment Required Error

Insufficient balance (`insufficient_credits`). The account balance is zero or below the price of this request. Top up, then send it again; not retryable before that.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 403 Forbidden Error

The key or account is not permitted to make this call (`forbidden`), for example a model that is not available on free credit (a top-up unlocks it), a request from outside the key's IP allowlist, or a model outside the key's group. Not retryable.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 409 Conflict Error

The `Idempotency-Key` was already used with a different request body, or the first request with it is still being processed (`idempotency_conflict`). Not retryable unchanged.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 429 Too Many Requests Error

Too many requests (`rate_limit_exceeded`, including the free-model limits) or too many tasks processing at once (`user_concurrency_exceeded`). Retryable after `Retry-After` seconds (also `error.retry_after_seconds`).

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 500 Internal Server Error

Unexpected internal error (`internal_error`). Retryable; keep `request_id` for support if it persists.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 503 Service Unavailable Error

The request could not be completed (`processing_unavailable`, `processing_timeout`, `processing_failed` or `result_transfer_failed`). Nothing was charged. Retryable with backoff; `Retry-After` is sent when the wait is known. BeatAPI does not answer 502 or 504.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

## Types

### ErrorError

Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

- `code` (enum, required) — Stable machine-readable error code. `unauthorized` is the deprecated name for a 401; since 2026-09-29 a 401 is `missing_api_key` or `invalid_api_key`. Treat a legacy `unauthorized` like `invalid_api_key`.
  - Allowed values: `bad_request`, `missing_api_key`, `invalid_api_key`, `unauthorized`, `forbidden`, `not_found`, `insufficient_credits`, `idempotency_conflict`, `user_concurrency_exceeded`, `rate_limit_exceeded`, `content_policy_violation`, `processing_unavailable`, `processing_failed`, `processing_timeout`, `result_transfer_failed`, `invalid_signature`, `realtime_disabled`, `realtime_capacity_unavailable`, `realtime_session_expired`, `origin_not_allowed`, `invalid_client_secret`, `transport_not_allowed`, `internal_error`
- `message` (string, required) — English sentence that states the cause; for `bad_request` it names the field. Written for people and logs, not for parsing.
- `retryable` (boolean, required) — Whether making the same call again could succeed. Present on every error; branch on it instead of the status code. True for 429, 500 and 503 (rate_limit_exceeded, user_concurrency_exceeded, internal_error, processing_unavailable, processing_timeout, processing_failed, result_transfer_failed, realtime_capacity_unavailable). False for a request, key or balance that must change first (bad_request, content_policy_violation, missing_api_key, invalid_api_key, insufficient_credits, forbidden, not_found, idempotency_conflict, realtime_disabled and the other realtime credential codes).
- `request_id` (string, required) — Correlation ID to retain for BeatAPI support.
- `retry_after_seconds` (integer, optional) — Seconds to wait before retrying. Present on every 429, and on a 503 when the wait is known; the same value is sent in the `Retry-After` header.
- `docs` (string, optional) — The public Skill page that says what to do about an error. Present on errors answered by the capability endpoints (`/v1/capabilities/search`, `/v1/capabilities/inspect`, `/v1/capabilities/run`); absent on every other endpoint.

## Examples

### Seedance 2

**Response**

```json
{
  "data": {
    "capability_id": "seedance-2",
    "capability_version": null,
    "completed_at": null,
    "created_at": 1782210000,
    "error_code": null,
    "error_message": null,
    "id": "task_8K2qA",
    "media_type": "video",
    "model": "seedance-2",
    "object": "task",
    "output": null,
    "request_id": "req_abc123",
    "stage": "queued",
    "status": "queued",
    "task_kind": "video",
    "updated_at": 1782210000,
    "usage": {
      "billable_duration_seconds": 8,
      "credits_charged": 2.96,
      "credits_refunded": 0,
      "credits_reserved": 2.96,
      "credits_settled": 0
    }
  }
}
```

**SDK Code**

```python Seedance 2
import requests

url = "https://api.beatapi.io/v1/videos/tasks"

headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript Seedance 2
const url = 'https://api.beatapi.io/v1/videos/tasks';
const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Seedance 2
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.beatapi.io/v1/videos/tasks"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Seedance 2
require 'uri'
require 'net/http'

url = URI("https://api.beatapi.io/v1/videos/tasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Seedance 2
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.beatapi.io/v1/videos/tasks")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Seedance 2
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.beatapi.io/v1/videos/tasks', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Seedance 2
using RestSharp;

var client = new RestClient("https://api.beatapi.io/v1/videos/tasks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Seedance 2
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.beatapi.io/v1/videos/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Text to video

**Request**

```json
{
  "model": "seedance-2",
  "prompt": "A handheld tracking shot through a crowded neon night market.",
  "duration": 8,
  "aspect_ratio": "16:9",
  "resolution": "1080p",
  "generate_audio": true
}
```

**Response**

```json
{
  "data": {
    "capability_id": "seedance-2",
    "capability_version": null,
    "completed_at": null,
    "created_at": 1782210000,
    "error_code": null,
    "error_message": null,
    "id": "task_8K2qA",
    "media_type": "video",
    "model": "seedance-2",
    "object": "task",
    "output": null,
    "request_id": "req_abc123",
    "stage": "queued",
    "status": "queued",
    "task_kind": "video",
    "updated_at": 1782210000,
    "usage": {
      "billable_duration_seconds": 8,
      "credits_charged": 2.96,
      "credits_refunded": 0,
      "credits_reserved": 2.96,
      "credits_settled": 0
    }
  }
}
```

**SDK Code**

```python Text to video
import requests

url = "https://api.beatapi.io/v1/videos/tasks"

payload = {
    "model": "seedance-2",
    "prompt": "A handheld tracking shot through a crowded neon night market.",
    "duration": 8,
    "aspect_ratio": "16:9",
    "resolution": "1080p",
    "generate_audio": True
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Text to video
const url = 'https://api.beatapi.io/v1/videos/tasks';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"model":"seedance-2","prompt":"A handheld tracking shot through a crowded neon night market.","duration":8,"aspect_ratio":"16:9","resolution":"1080p","generate_audio":true}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Text to video
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.beatapi.io/v1/videos/tasks"

	payload := strings.NewReader("{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"A handheld tracking shot through a crowded neon night market.\",\n  \"duration\": 8,\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Text to video
require 'uri'
require 'net/http'

url = URI("https://api.beatapi.io/v1/videos/tasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"A handheld tracking shot through a crowded neon night market.\",\n  \"duration\": 8,\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}"

response = http.request(request)
puts response.read_body
```

```java Text to video
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.beatapi.io/v1/videos/tasks")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"A handheld tracking shot through a crowded neon night market.\",\n  \"duration\": 8,\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}")
  .asString();
```

```php Text to video
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.beatapi.io/v1/videos/tasks', [
  'body' => '{
  "model": "seedance-2",
  "prompt": "A handheld tracking shot through a crowded neon night market.",
  "duration": 8,
  "aspect_ratio": "16:9",
  "resolution": "1080p",
  "generate_audio": true
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Text to video
using RestSharp;

var client = new RestClient("https://api.beatapi.io/v1/videos/tasks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"A handheld tracking shot through a crowded neon night market.\",\n  \"duration\": 8,\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Text to video
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "model": "seedance-2",
  "prompt": "A handheld tracking shot through a crowded neon night market.",
  "duration": 8,
  "aspect_ratio": "16:9",
  "resolution": "1080p",
  "generate_audio": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.beatapi.io/v1/videos/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### First frame

**Request**

```json
{
  "model": "seedance-2",
  "prompt": "Animate the performer with a slow push-in and natural fabric movement.",
  "images": [
    "https://media.beatapi.io/samples/neon-singer.png"
  ],
  "duration": 5,
  "resolution": "1080p",
  "generate_audio": true
}
```

**Response**

```json
{
  "data": {
    "capability_id": "seedance-2",
    "capability_version": null,
    "completed_at": null,
    "created_at": 1782210000,
    "error_code": null,
    "error_message": null,
    "id": "task_8K2qA",
    "media_type": "video",
    "model": "seedance-2",
    "object": "task",
    "output": null,
    "request_id": "req_abc123",
    "stage": "queued",
    "status": "queued",
    "task_kind": "video",
    "updated_at": 1782210000,
    "usage": {
      "billable_duration_seconds": 8,
      "credits_charged": 2.96,
      "credits_refunded": 0,
      "credits_reserved": 2.96,
      "credits_settled": 0
    }
  }
}
```

**SDK Code**

```python First frame
import requests

url = "https://api.beatapi.io/v1/videos/tasks"

payload = {
    "model": "seedance-2",
    "prompt": "Animate the performer with a slow push-in and natural fabric movement.",
    "images": ["https://media.beatapi.io/samples/neon-singer.png"],
    "duration": 5,
    "resolution": "1080p",
    "generate_audio": True
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript First frame
const url = 'https://api.beatapi.io/v1/videos/tasks';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"model":"seedance-2","prompt":"Animate the performer with a slow push-in and natural fabric movement.","images":["https://media.beatapi.io/samples/neon-singer.png"],"duration":5,"resolution":"1080p","generate_audio":true}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go First frame
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.beatapi.io/v1/videos/tasks"

	payload := strings.NewReader("{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Animate the performer with a slow push-in and natural fabric movement.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"duration\": 5,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby First frame
require 'uri'
require 'net/http'

url = URI("https://api.beatapi.io/v1/videos/tasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Animate the performer with a slow push-in and natural fabric movement.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"duration\": 5,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}"

response = http.request(request)
puts response.read_body
```

```java First frame
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.beatapi.io/v1/videos/tasks")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Animate the performer with a slow push-in and natural fabric movement.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"duration\": 5,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}")
  .asString();
```

```php First frame
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.beatapi.io/v1/videos/tasks', [
  'body' => '{
  "model": "seedance-2",
  "prompt": "Animate the performer with a slow push-in and natural fabric movement.",
  "images": [
    "https://media.beatapi.io/samples/neon-singer.png"
  ],
  "duration": 5,
  "resolution": "1080p",
  "generate_audio": true
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp First frame
using RestSharp;

var client = new RestClient("https://api.beatapi.io/v1/videos/tasks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Animate the performer with a slow push-in and natural fabric movement.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"duration\": 5,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift First frame
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "model": "seedance-2",
  "prompt": "Animate the performer with a slow push-in and natural fabric movement.",
  "images": ["https://media.beatapi.io/samples/neon-singer.png"],
  "duration": 5,
  "resolution": "1080p",
  "generate_audio": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.beatapi.io/v1/videos/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Multimodal references

**Request**

```json
{
  "model": "seedance-2",
  "prompt": "Create a synchronized performance from the supplied image and audio references.",
  "reference_images": [
    "https://media.beatapi.io/samples/neon-singer.png"
  ],
  "reference_audios": [
    "https://media.beatapi.io/samples/neon-singer-preview.mp3"
  ],
  "duration": 8,
  "resolution": "1080p",
  "generate_audio": true
}
```

**Response**

```json
{
  "data": {
    "capability_id": "seedance-2",
    "capability_version": null,
    "completed_at": null,
    "created_at": 1782210000,
    "error_code": null,
    "error_message": null,
    "id": "task_8K2qA",
    "media_type": "video",
    "model": "seedance-2",
    "object": "task",
    "output": null,
    "request_id": "req_abc123",
    "stage": "queued",
    "status": "queued",
    "task_kind": "video",
    "updated_at": 1782210000,
    "usage": {
      "billable_duration_seconds": 8,
      "credits_charged": 2.96,
      "credits_refunded": 0,
      "credits_reserved": 2.96,
      "credits_settled": 0
    }
  }
}
```

**SDK Code**

```python Multimodal references
import requests

url = "https://api.beatapi.io/v1/videos/tasks"

payload = {
    "model": "seedance-2",
    "prompt": "Create a synchronized performance from the supplied image and audio references.",
    "reference_images": ["https://media.beatapi.io/samples/neon-singer.png"],
    "reference_audios": ["https://media.beatapi.io/samples/neon-singer-preview.mp3"],
    "duration": 8,
    "resolution": "1080p",
    "generate_audio": True
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Multimodal references
const url = 'https://api.beatapi.io/v1/videos/tasks';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"model":"seedance-2","prompt":"Create a synchronized performance from the supplied image and audio references.","reference_images":["https://media.beatapi.io/samples/neon-singer.png"],"reference_audios":["https://media.beatapi.io/samples/neon-singer-preview.mp3"],"duration":8,"resolution":"1080p","generate_audio":true}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Multimodal references
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.beatapi.io/v1/videos/tasks"

	payload := strings.NewReader("{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Create a synchronized performance from the supplied image and audio references.\",\n  \"reference_images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"reference_audios\": [\n    \"https://media.beatapi.io/samples/neon-singer-preview.mp3\"\n  ],\n  \"duration\": 8,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Multimodal references
require 'uri'
require 'net/http'

url = URI("https://api.beatapi.io/v1/videos/tasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Create a synchronized performance from the supplied image and audio references.\",\n  \"reference_images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"reference_audios\": [\n    \"https://media.beatapi.io/samples/neon-singer-preview.mp3\"\n  ],\n  \"duration\": 8,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}"

response = http.request(request)
puts response.read_body
```

```java Multimodal references
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.beatapi.io/v1/videos/tasks")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Create a synchronized performance from the supplied image and audio references.\",\n  \"reference_images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"reference_audios\": [\n    \"https://media.beatapi.io/samples/neon-singer-preview.mp3\"\n  ],\n  \"duration\": 8,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}")
  .asString();
```

```php Multimodal references
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.beatapi.io/v1/videos/tasks', [
  'body' => '{
  "model": "seedance-2",
  "prompt": "Create a synchronized performance from the supplied image and audio references.",
  "reference_images": [
    "https://media.beatapi.io/samples/neon-singer.png"
  ],
  "reference_audios": [
    "https://media.beatapi.io/samples/neon-singer-preview.mp3"
  ],
  "duration": 8,
  "resolution": "1080p",
  "generate_audio": true
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Multimodal references
using RestSharp;

var client = new RestClient("https://api.beatapi.io/v1/videos/tasks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"model\": \"seedance-2\",\n  \"prompt\": \"Create a synchronized performance from the supplied image and audio references.\",\n  \"reference_images\": [\n    \"https://media.beatapi.io/samples/neon-singer.png\"\n  ],\n  \"reference_audios\": [\n    \"https://media.beatapi.io/samples/neon-singer-preview.mp3\"\n  ],\n  \"duration\": 8,\n  \"resolution\": \"1080p\",\n  \"generate_audio\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Multimodal references
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "model": "seedance-2",
  "prompt": "Create a synchronized performance from the supplied image and audio references.",
  "reference_images": ["https://media.beatapi.io/samples/neon-singer.png"],
  "reference_audios": ["https://media.beatapi.io/samples/neon-singer-preview.mp3"],
  "duration": 8,
  "resolution": "1080p",
  "generate_audio": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.beatapi.io/v1/videos/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```