# seedance-2.0/image-to-video

> Seedance 2.0 (Image-to-Video) generates Hollywood-grade cinematic videos from reference images and text prompts with native audio-visual synchronization, director-level camera and lighting control, and exceptional motion stability. Built on Seed's unified multimodal architecture, it preserves the input image's subject and composition while adding expressive, physically accurate motion.

- **Provider:** ByteDance
- **Category:** image-to-video
- **Price:** $0.4080 (~~$0.4800~~) per run

## Key Features

- Image-faithful generation — preserves the reference image's subject identity, composition and lighting while animating it into natural motion.
- Multi-image reference support — guide generation with up to 4 reference images for consistent style, characters or scenes.
- Native audio-visual synchronization — generates video with synchronized audio in a single pass (enabled by default).
- Director-level control — granular control over camera movement, lighting, shadows and character performance through prompts.
- Exceptional motion stability — industry-leading motion coherence with stable subjects, consistent physics and fluid transitions.
- Up to 4K resolution with duration from 4 to 15 seconds for production-ready output.

## 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-15 (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), 1080p, or 4k. |
| `enable_web_search` | No | Enable web search for enhanced prompt understanding. |
| `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 15 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.0/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.0/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.0/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.0/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.0/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.0/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.48 |
| 480p | 5s | $0.60 |
| 480p | 6s | $0.72 |
| 480p | 8s | $0.96 |
| 480p | 10s | $1.20 |
| 480p | 12s | $1.44 |
| 480p | 15s | $1.80 |
| 720p | 4s | $0.96 |
| 720p | 5s | $1.20 |
| 720p | 6s | $1.44 |
| 720p | 8s | $1.92 |
| 720p | 10s | $2.40 |
| 720p | 12s | $2.88 |
| 720p | 15s | $3.60 |
| 1080p | 4s | $2.40 |
| 1080p | 5s | $3.00 |
| 1080p | 6s | $3.60 |
| 1080p | 8s | $4.80 |
| 1080p | 10s | $6.00 |
| 1080p | 12s | $7.20 |
| 1080p | 15s | $9.00 |
| 4k | 4s | $4.80 |
| 4k | 5s | $6.00 |
| 4k | 6s | $7.20 |
| 4k | 8s | $9.60 |
| 4k | 10s | $12.00 |
| 4k | 12s | $14.40 |
| 4k | 15s | $18.00 |

### Billing Rules

- 480p / 4s: $0.48.
- 720p / 4s: $0.96.
- 1080p / 4s: $2.40.
- 4k / 4s: $4.80.
- Longer durations scale proportionally.
- Failed generations are not charged.

## Best Use Cases

- Product demos — animate product shots into cinematic showcase videos.
- Commercials — create 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 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 multiple reference images for better style and character consistency.
- Start with a short duration (4-5s) to iterate, then extend up to 15s 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.
- Up to 4 reference images can be uploaded.
- Duration range: 4-15 seconds (continuous).
- Median generation time: approximately 170 seconds.

## FAQ

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

seedance-2.0/image-to-video is an image-to-video API optimized on the Seedance 2.0 architecture. This model has been comprehensively upgraded in smoothness of human motion, physically based lighting rendering, interpretation of complex camera angles, and consistency of long-sequence footage. Users only need to provide a static image (with optional action cues) to quickly convert it into a high-definition, highly dynamic, and 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.0 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.0, Sora, Runway, Kling, Luma, and Wan 2.2, 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 and frame rate: 720p/1080p HD generation, outputting stable 24/30 FPS MP4 video. Camera movement and motion control: motion intensity (motion_scale), camera movement trajectory (e.g. panning, zooming in, zooming out), text guidance coefficient (cfg_scale), and random seed. Video duration: standard 5-second generation by default, extendable for longer videos.

**Q: What are the billing rules and inquiries for the image-to-video 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. Transparent details: the console's call log records the time consumed, resolution specifications, and billing details for each API request in real time, facilitating cost accounting and optimization.

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

Check image URL connectivity: ensure the submitted image_url is publicly accessible without cookies or anti-hotlinking measures and that the subject is clearly visible. Enrich the prompt description: add explicit dynamic verbs (e.g. "The sea breeze blows through the hair, the camera slowly pans to the left") and avoid passing only static nouns or empty prompts. Adjust motion amplitude: if the image shows limb stretching or excessive distortion, appropriately reduce the motion_scale parameter to improve stability.