> ## 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 Mini Lite Image to Video

> Seedance 2.0 Mini Lite Image to Video is a special-price full-capability 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. This is the special-price full-capability route: media URLs are reviewed by the asset service before submission, so plain public URLs still work in requests.



## OpenAPI

````yaml api-reference/openapi/seedance--2-0-mini-lite-image-to-video.yaml POST /v1/videos/generations
openapi: 3.1.0
info:
  title: Seedance 2.0 Mini Lite Image to Video API
  version: 1.0.0
  description: >-
    Seedance 2.0 Mini Lite is a special-price mini 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-mini-lite-i2v. Results are returned
    through asynchronous video tasks. This is the special-price full-capability
    variant: media URLs are reviewed by the asset service before the task is
    submitted, so plain public URLs still work in requests.
servers:
  - url: https://api.apipod.ai
    description: Production
security: []
paths:
  /v1/videos/generations:
    post:
      tags:
        - Seedance 2.0 Mini Lite Image to Video
      summary: Create Generation Task
      description: >-
        Seedance 2.0 Mini Lite is a special-price mini 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-mini-lite-i2v.
        Results are returned through asynchronous video tasks. This is the
        special-price full-capability variant: media URLs are reviewed by the
        asset service before the task is submitted, so plain public URLs still
        work in requests.
      operationId: create-seedance-2-0-mini-lite-image-to-video
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: Seedance 2.0 Mini Lite Image to Video
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: seedance-2.0-mini-lite-i2v
                prompt:
                  type: string
                  title: Prompt
                  maxLength: 1000
                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:
                    - 720p
                  default: 720p
                watermark:
                  type: boolean
                  title: Watermark
                  description: Whether the generated video contains a watermark.
                  default: false
                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'
                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
              required:
                - model
                - prompt
                - image_urls
            example:
              model: seedance-2.0-mini-lite-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-mini-lite-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-mini-lite-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-mini-lite-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-mini-lite-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-mini-lite-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.

````