# seedance-2.5/image-to-video

> Seedance 2.5 (Image-to-Video) turns a reference image and prompt into native cinematic video up to 30 seconds, with up to 50 full-modal reference assets, richer editing control, and native audio-visual synchronization. Built on ByteDance's next-generation Seed architecture, it preserves the input image's subject and composition while adding expressive, physically accurate motion.

- **Provider:** ByteDance
- **Category:** image-to-video
- **Price:** $0.7600 per run

## Key Features

- Native 30-second clips — up to 6x the duration ceiling of Seedance 2.0, with room for multi-beat scenes in a single generation.
- Up to 50 full-modal reference assets — the richest reference budget in the Seedance family for complex multi-character, multi-scene compositions.
- Image-faithful generation — preserves the reference image's subject identity, composition and lighting while animating it into natural motion.
- Native audio-visual synchronization — generates video with synchronized audio in a single pass (enabled by default).
- Sharper editing and generation control — ByteDance's next-generation Seed architecture improves precision over Seedance 2.0 in both prompt adherence and reference fidelity.
- Director-level control over camera movement, lighting, shadows and character performance through prompts.

## Parameters

| Parameter | Required | Description |
| --- | --- | --- |
| `prompt` | Yes | Detailed description of the cinematic scene and desired motion. |
| `image` | Yes | Start image URL to guide the video generation. |
| `last_image` | No | Last frame image URL for video continuation. |
| `duration` | No | Video length in seconds: 4-30 (default: 5). |
| `aspect_ratio` | No | Output format: 16:9, 9:16, 4:3, 3:4, 1:1, 21:9 (default: 16:9). |
| `resolution` | No | Output resolution: 480p, 720p (default), or 1080p. |
| `bitrate_mode` | No | Bitrate quality: standard (default) or high. |
| `generate_audio` | No | Generate synchronized audio (default: true). |

## How to Use

1. Upload a start image to guide the video generation.
2. Write your prompt — describe the scene with cinematic detail: action, camera movement, lighting, mood.
3. Set duration — choose any duration from 4 to 30 seconds.
4. Run — submit and download your cinematic video with synchronized audio.

## Code Examples

### Python

```python
import os
import requests

response = requests.post(
    "https://aircube.ai/api/v3/seedance-2.5/image-to-video",
    headers={
        "Authorization": "Bearer " + os.environ["AIRCUBE_API_KEY"],
        "Content-Type": "application/json",
    },
    json={
    "prompt": "A woman slowly turns her head and smiles, soft golden hour lighting, cinematic depth of field",
    "image": "https://example.com/portrait.jpg",
    "duration": 5,
    "resolution": "1080p",
    "generate_audio": true
},
    timeout=300,
)
data = response.json()

if data["success"]:
    print("ID:", data["data"]["id"], "Status:", data["data"]["status"])
else:
    print("Error:", data["error"]["message"])
```

### Node.js

```javascript
const response = await fetch("https://aircube.ai/api/v3/seedance-2.5/image-to-video", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + process.env.AIRCUBE_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
  "prompt": "A woman slowly turns her head and smiles, soft golden hour lighting, cinematic depth of field",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "resolution": "1080p",
  "generate_audio": true
}),
});

const data = await response.json();

if (data.success) {
  console.log("ID:", data.data.id, "Status:", data.data.status);
} else {
  console.error("Error:", data.error.message);
}
```

### cURL

```curl
curl -X POST "https://aircube.ai/api/v3/seedance-2.5/image-to-video" \
  -H "Authorization: Bearer $AIRCUBE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "prompt": "A woman slowly turns her head and smiles, soft golden hour lighting, cinematic depth of field",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "resolution": "1080p",
  "generate_audio": true
}'
```

### Python (Async)

```python
import os
import time
import requests

# 1. Submit
response = requests.post(
    "https://aircube.ai/api/v3/seedance-2.5/image-to-video",
    headers={
        "Authorization": "Bearer " + os.environ["AIRCUBE_API_KEY"],
        "Content-Type": "application/json",
    },
    json={
    "prompt": "A woman slowly turns her head and smiles, soft golden hour lighting, cinematic depth of field",
    "image": "https://example.com/portrait.jpg",
    "duration": 5,
    "resolution": "1080p",
    "generate_audio": true
},
    timeout=300,
)
data = response.json()

if not data["success"]:
    print("Error:", data["error"]["message"])
    exit(1)

generation_id = data["data"]["id"]
print(f"Submitted: {generation_id}")

# 2. Poll until completed
while True:
    time.sleep(5)
    r = requests.get(
        f"https://aircube.ai/api/v3/status/{generation_id}",
        headers={"Authorization": "Bearer " + os.environ["AIRCUBE_API_KEY"]},
    )
    result = r.json()["data"]

    if result["status"] == "completed":
        print(result["output_url"])
        break
    elif result["status"] == "failed":
        print("Generation failed")
        break
```

### Node.js (Async)

```javascript
// 1. Submit
const response = await fetch("https://aircube.ai/api/v3/seedance-2.5/image-to-video", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + process.env.AIRCUBE_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
  "prompt": "A woman slowly turns her head and smiles, soft golden hour lighting, cinematic depth of field",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "resolution": "1080p",
  "generate_audio": true
}),
});
const data = await response.json();

if (!data.success) {
  console.error("Error:", data.error.message);
  process.exit(1);
}

const generationId = data.data.id;
console.log("Submitted:", generationId);

// 2. Poll until completed
while (true) {
  await new Promise((r) => setTimeout(r, 5000));
  const res = await fetch(
    `https://aircube.ai/api/v3/status/${generationId}`,
    { headers: { "Authorization": "Bearer " + process.env.AIRCUBE_API_KEY } },
  );
  const result = (await res.json()).data;

  if (result.status === "completed") {
    console.log(result.output_url);
    break;
  } else if (result.status === "failed") {
    console.error("Generation failed");
    break;
  }
}
```

### cURL (Async)

```curl
# 1. Submit
RESPONSE=$(curl -s -X POST "https://aircube.ai/api/v3/seedance-2.5/image-to-video" \
  -H "Authorization: Bearer $AIRCUBE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "prompt": "A woman slowly turns her head and smiles, soft golden hour lighting, cinematic depth of field",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "resolution": "1080p",
  "generate_audio": true
}')

ID=$(echo "$RESPONSE" | jq -r '.data.id')
echo "Submitted: $ID"

# 2. Poll until completed
while true; do
  sleep 5
  STATUS_RES=$(curl -s "https://aircube.ai/api/v3/status/$ID" \
    -H "Authorization: Bearer $AIRCUBE_API_KEY")
  STATUS=$(echo "$STATUS_RES" | jq -r '.data.status')

  if [ "$STATUS" = "completed" ]; then
    echo "$STATUS_RES" | jq -r '.data.output_url'
    break
  elif [ "$STATUS" = "failed" ]; then
    echo "Generation failed"; break
  fi
done
```

## Pricing

| Resolution | Duration | Cost |
| --- | --- | --- |
| 480p | 4s | $0.76 |
| 480p | 5s | $0.95 |
| 480p | 6s | $1.14 |
| 480p | 8s | $1.52 |
| 480p | 10s | $1.90 |
| 480p | 12s | $2.28 |
| 480p | 15s | $2.85 |
| 480p | 20s | $3.80 |
| 480p | 25s | $4.75 |
| 480p | 30s | $5.70 |
| 720p | 4s | $1.76 |
| 720p | 5s | $2.20 |
| 720p | 6s | $2.64 |
| 720p | 8s | $3.52 |
| 720p | 10s | $4.40 |
| 720p | 12s | $5.28 |
| 720p | 15s | $6.60 |
| 720p | 20s | $8.80 |
| 720p | 25s | $11.00 |
| 720p | 30s | $13.20 |
| 1080p | 4s | $4.20 |
| 1080p | 5s | $5.25 |
| 1080p | 6s | $6.30 |
| 1080p | 8s | $8.40 |
| 1080p | 10s | $10.50 |
| 1080p | 12s | $12.60 |
| 1080p | 15s | $15.75 |
| 1080p | 20s | $21.00 |
| 1080p | 25s | $26.25 |
| 1080p | 30s | $31.50 |

### Billing Rules

- 480p / 4s: $0.76.
- 720p / 4s: $1.76.
- 1080p / 4s: $4.20.
- Longer durations scale proportionally.
- Failed generations are not charged.

## Best Use Cases

- Product demos — animate product shots into cinematic, multi-beat showcase videos.
- Commercials — create longer-form professional ad content from reference imagery.
- Character animation — animate characters or artwork into full cinematic footage.
- Scene extension — transform a single keyframe into a full 30-second cinematic sequence.
- Style-consistent series — use reference images to maintain visual consistency across multiple clips.

## Pro Tips

- Upload high-quality reference images for the best subject preservation.
- Write prompts like a film director — include lighting, camera angles and mood.
- Use the extended 30-second ceiling for scenes with more than one narrative beat.
- Start with a short duration (4-5s) to iterate, then extend up to 30s for the final cut.
- Describe character expressions and actions for more engaging scenes.

## Notes

- Native audio generation is included by default — videos come with synchronized sound.
- Duration range: 4-30 seconds (continuous).
- Supports up to 1080p output resolution.
- Successor to Seedance 2.0 with a longer duration ceiling and richer reference support.

## FAQ

**Q: What is the seedance-2.5/image-to-video API on this platform?**

seedance-2.5/image-to-video is an image-to-video API built on ByteDance's next-generation Seedance 2.5 architecture. Compared with Seedance 2.0, it expands the usable creative window from short clips into native videos up to 30 seconds, supports up to 50 full-modal reference assets, and improves the precision of generation and editing control. Users only need to provide a static image (with optional action cues) to render a high-definition, highly dynamic, physically consistent video clip.

**Q: Compared to directly connecting to the official site or a self-built cluster, what are the advantages of calling Seedance 2.5 through this platform's API?**

Unified API key management: a single API key from this platform allows concurrent calls to mainstream AI video models across the web, including Seedance 2.5, Sora, Runway, Kling, Luma, and Wan 3.0, eliminating the need to maintain multiple accounts and payment systems. High-speed rendering and intelligent disaster recovery: built-in distributed GPU cluster load balancing automatically triggers low-latency routing and failure retries when model nodes are congested, significantly improving the generation success rate under high concurrency. Elastic billing and refunds for failures: enjoy tiered discounts on aggregated procurement, charged based on successful output — if a task fails due to risk control blocking or timeout, the system automatically provides a full refund. Out of the box: standard RESTful API specifications, asynchronous webhook callbacks, and multi-language SDK examples allow business integration within minutes.

**Q: What input parameters and generation specifications does the interface support?**

Input image requirements: PNG, JPG, JPEG, and WebP formats (recommended aspect ratios 16:9, 9:16, and 1:1; HTTPS direct links accessible over the public internet; file size less than 10MB). Resolution: 480p, 720p, or 1080p HD generation, outputting stable MP4 video. Duration: 4 to 30 seconds, continuously adjustable — double the ceiling of Seedance 2.0. Reference budget: up to 50 combined reference images, videos, and audio clips for the reference-to-video mode, addressed with @image1/@video1/@audio1 tags in the prompt. Camera and bitrate control: camera movement trajectory (e.g. panning, zooming in, zooming out) and bitrate_mode (standard/high) for output quality.

**Q: What are the billing rules and inquiries for the Seedance 2.5 API?**

Billing based on successful rendering: the system only deducts account balance when a valid MP4 video URL is successfully returned; if a server-side exception or request timeout occurs, the pre-deducted amount is automatically refunded in full. Pricing is per-second at $0.12 (480p), $0.27 (720p), or $0.50 (1080p) of output duration; reference videos add a per-second surcharge at $0.07/$0.16/$0.30 respectively. Transparent details: the console's call log records the time consumed, resolution specifications, and billing details for each API request in real time.

**Q: How to troubleshoot and optimize when video generation results are poor or requests fail?**

Check image or reference URL connectivity: ensure all submitted URLs are publicly accessible without cookies or anti-hotlinking measures and that the subject is clearly visible. Enrich the prompt description: add explicit dynamic verbs and, for reference-to-video, use the "@asset = instruction" format to give each reference asset a clear role (e.g. "@image1 = her: keep the exact face, she is the lead dancer"). Trim reference videos to the most relevant segment — reference video and audio inputs are capped at a combined duration per request.