> ## Documentation Index
> Fetch the complete documentation index at: https://docs.apipod.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Seedance 2.0 Image to Video

> Seedance 2.0 Image to Video is a standard route that animates a required first-frame image and can use an optional last frame where the public schema allows it. Media URLs are submitted to asset review before task creation by default (real_person=true); set real_person=false only when the materials are confirmed face-free.

## Real-person review (real\_person)

When a request carries reference materials, the boolean `real_person` field controls whether materials are submitted to face review first:

* `real_person: true` (default): materials are submitted to the asset review service first, and the task is created with `assetId://{assetId}` references; the task waits during review and fails if review rejects the materials.
* `real_person: false`: review is skipped and material URLs are passed through to task creation as-is.

Set it to `false` only when the materials are confirmed face-free to save the review round trip; keep the default `true` for materials containing real people.

## Asset library references

Besides publicly accessible URLs, the `image_url` / `image_urls`, `video_urls`, and `audio_url` / `audio_urls` fields also accept asset library references in the form `assetId://{assetId}`. Asset IDs are shared across the platform: any account may reference a known `assetId`, regardless of who submitted it — the same sharing semantics as a public URL. Only `ACTIVE` assets pass validation. Submit and track assets via [asset upload](/seedance/asset-upload) and [asset detail](/seedance/asset-detail).


## OpenAPI

````yaml api-reference/openapi/seedance--2-0-image-to-video.yaml POST /v1/videos/generations
openapi: 3.1.0
info:
  title: Seedance 2.0 Image to Video API
  version: 1.0.0
  description: >-
    Seedance 2.0 Image to Video is a standard route that animates a required
    first-frame image and can use an optional last frame where the public schema
    allows it. The Seedance family emphasizes prompt following, coherent motion,
    multi-shot storytelling, and synchronized audio. In APIPod, the public model
    ID is seedance-2.0-i2v. It supports image-to-video, accepts text and image
    inputs, and returns results through asynchronous video tasks. Media URLs are
    submitted to asset review before task creation by default
    (real_person=true); set real_person=false only when the materials are
    confirmed face-free to pass them through without review.
servers:
  - url: https://api.apipod.ai
    description: Production
security: []
paths:
  /v1/videos/generations:
    post:
      tags:
        - Seedance 2.0 Image to Video
      summary: Create Generation Task
      description: >-
        Seedance 2.0 Image to Video is a standard route that animates a required
        first-frame image and can use an optional last frame where the public
        schema allows it. The Seedance family emphasizes prompt following,
        coherent motion, multi-shot storytelling, and synchronized audio. In
        APIPod, the public model ID is seedance-2.0-i2v. It supports
        image-to-video, accepts text and image inputs, and returns results
        through asynchronous video tasks. Media URLs are submitted to asset
        review before task creation by default (real_person=true); set
        real_person=false only when the materials are confirmed face-free to
        pass them through without review.
      operationId: create-seedance-2-0-image-to-video
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: Seedance 2.0 Image to Video
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: seedance-2.0-i2v
                prompt:
                  type: string
                  title: Prompt
                  maxLength: 30000
                  description: >-
                    Generation or editing instructions, up to 30000 characters.
                    It is recommended to keep the prompt to no more than 500
                    Chinese characters or 1,000 English words. Lengthy text will
                    lead to scattered information, and the model may ignore
                    details and only focus on key points, resulting in missing
                    elements in the generated video.
                image_urls:
                  type: array
                  title: Image Urls
                  items:
                    type: string
                duration:
                  type: integer
                  title: Duration
                  enum:
                    - 4
                    - 5
                    - 6
                    - 7
                    - 8
                    - 9
                    - 10
                    - 11
                    - 12
                    - 13
                    - 14
                    - 15
                  default: 5
                  minimum: 4
                  maximum: 15
                resolution:
                  type: string
                  title: Resolution
                  description: Generate video resolution.
                  enum:
                    - 480p
                    - 720p
                    - 1080p
                    - 4k
                  default: 720p
                aspect_ratio:
                  type: string
                  title: Aspect Ratio
                  description: >
                    Aspect ratio of the generated video,When the ratio is
                    configured as adaptive,automatically select the closest
                    aspect ratio based on the proportion of the uploaded first
                    frame image.
                  enum:
                    - adaptive
                    - '4:3'
                    - '1:1'
                    - '3:4'
                    - '9:16'
                    - '16:9'
                    - '21:9'
                  default: '16:9'
                watermark:
                  type: boolean
                  title: Watermark
                  description: Whether the generated video contains a watermark.
                  default: false
                web_search:
                  type: boolean
                  title: Web Search
                  description: >-
                    After enabling, the model will independently decide whether
                    to search Internet content (such as products, weather, etc.)
                    based on the user's prompt. This can improve the timeliness
                    of generated videos but will also introduce a certain degree
                    of latency.
                  default: false
                generate_audio:
                  type: boolean
                  title: Generate Audio
                  description: >-
                    Controls whether the generated video contains audio
                    synchronized with the visuals.
                  default: true
                return_last_frame:
                  type: boolean
                  title: Return Last Frame
                  description: >-
                    Whether to return the last frame image of the generated
                    video. Using this parameter enables the generation of
                    multiple consecutive videos: taking the last frame of the
                    previous generated video as the first frame of the next
                    video task to quickly generate multiple consecutive videos,
                    and the first item in the returned result is this image.
                  default: false
                real_person:
                  type: boolean
                  title: Real Person
                  description: >-
                    Whether the reference materials contain real people (human
                    faces). Defaults to true: materials are submitted to the
                    asset review service and replaced with assetId:// references
                    before task creation. Set to false only when the materials
                    are confirmed face-free to skip review and pass material
                    URLs through as-is.
                  default: true
              required:
                - model
                - prompt
                - image_urls
            example:
              model: seedance-2.0-i2v
              prompt: >-
                Animate the subject with a slow camera push-in, natural motion,
                and soft cinematic lighting.
              image_urls:
                - https://cdn.example.com/reference-1.jpg
              duration: 5
              resolution: 720p
              aspect_ratio: '16:9'
              generate_audio: true
      responses:
        '200':
          description: Task accepted
          content:
            application/json:
              schema:
                type: object
                title: Task Submit Response
                description: Standard response for task submission
                properties:
                  code:
                    type: integer
                  data:
                    type: object
                    title: Task Submit Data
                    description: Data content for task submission
                    properties:
                      task_id:
                        type: string
                        description: generatation task id
                  message:
                    type: string
                required:
                  - code
                  - message
                  - data
              example:
                code: 200
                message: success
                data:
                  task_id: vid_task_01JEXAMPLE
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: Shell
          label: cURL
          source: |-
            curl https://api.apipod.ai/v1/videos/generations \
              -H "Authorization: Bearer $APIPOD_API_KEY" \
              -H "Content-Type: application/json" \
              -d '{
              "model": "seedance-2.0-i2v",
              "prompt": "Animate the subject with a slow camera push-in, natural motion, and soft cinematic lighting.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9",
              "generate_audio": true
            }'
        - lang: Python
          label: Python
          source: |-
            import os
            import requests

            payload = {
              "model": "seedance-2.0-i2v",
              "prompt": "Animate the subject with a slow camera push-in, natural motion, and soft cinematic lighting.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9",
              "generate_audio": True
            }

            response = requests.post(
                "https://api.apipod.ai/v1/videos/generations",
                headers={
                    "Authorization": f"Bearer {os.environ['APIPOD_API_KEY']}",
                    "Content-Type": "application/json",
                },
                json=payload,
                timeout=60,
            )
            response.raise_for_status()
            print(response.json())
        - lang: Go
          label: Go
          source: |-
            package main

            import (
                "bytes"
                "encoding/json"
                "fmt"
                "net/http"
                "os"
            )

            func main() {
                payload := map[string]any{}
                if err := json.Unmarshal([]byte(`{
              "model": "seedance-2.0-i2v",
              "prompt": "Animate the subject with a slow camera push-in, natural motion, and soft cinematic lighting.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9",
              "generate_audio": true
            }`), &payload); err != nil {
                    panic(err)
                }
                body, err := json.Marshal(payload)
                if err != nil {
                    panic(err)
                }

                req, err := http.NewRequest(http.MethodPost, "https://api.apipod.ai/v1/videos/generations", bytes.NewReader(body))
                if err != nil {
                    panic(err)
                }
                req.Header.Set("Authorization", "Bearer "+os.Getenv("APIPOD_API_KEY"))
                req.Header.Set("Content-Type", "application/json")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                    panic(err)
                }
                defer resp.Body.Close()
                fmt.Println(resp.Status)
            }
        - lang: Rust
          label: Rust
          source: |-
            use reqwest::Client;
            use serde_json::json;
            use std::env;

            #[tokio::main]
            async fn main() -> Result<(), Box<dyn std::error::Error>> {
                let payload = json!({
              "model": "seedance-2.0-i2v",
              "prompt": "Animate the subject with a slow camera push-in, natural motion, and soft cinematic lighting.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9",
              "generate_audio": true
            });
                let response = Client::new()
                    .post("https://api.apipod.ai/v1/videos/generations")
                    .bearer_auth(env::var("APIPOD_API_KEY")?)
                    .json(&payload)
                    .send()
                    .await?
                    .error_for_status()?;

                println!("{}", response.text().await?);
                Ok(())
            }
        - lang: JavaScript
          label: JavaScript
          source: >-
            const response = await
            fetch("https://api.apipod.ai/v1/videos/generations", {
              method: "POST",
              headers: {
                Authorization: `Bearer ${process.env.APIPOD_API_KEY}`,
                "Content-Type": "application/json",
              },
              body: JSON.stringify(
              {
                "model": "seedance-2.0-i2v",
                "prompt": "Animate the subject with a slow camera push-in, natural motion, and soft cinematic lighting.",
                "image_urls": [
                  "https://cdn.example.com/reference-1.jpg"
                ],
                "duration": 5,
                "resolution": "720p",
                "aspect_ratio": "16:9",
                "generate_audio": true
              }
              ),
            });


            if (!response.ok) {
              throw new Error(`APIPod request failed: ${response.status} ${await response.text()}`);
            }


            console.log(await response.json());
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: APIPod API key
      description: Use your APIPod API key as a Bearer token in the Authorization header.

````