> ## 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.5 X Reference to Video

> Seedance 2.5 X Reference to Video is the lowest-cost multimodal route in APIPod's Seedance 2.5 family, billed per second.

<Warning title="Conditional validation">Provide at least one reference asset. The per-media limits are defined by the API schema.</Warning>


## OpenAPI

````yaml api-reference/openapi/seedance--2-5-x-reference-to-video.yaml POST /v1/videos/generations
openapi: 3.1.0
info:
  title: Seedance 2.5 X Reference to Video API
  version: 1.0.0
  description: >-
    Seedance 2.5 X Reference to Video is the lowest-cost multimodal route in
    APIPod's Seedance 2.5 family, billed per second. It combines up to 30
    reference images, 10 videos and 10 audios into a 5-30 second 720p video in
    eight aspect ratios; audio must be paired with at least one image or video,
    and reference video duration is billed together with the output duration.
    First/last-frame image-to-video is not offered on this tier because the
    upstream has no dedicated frame fields. In APIPod, the public model ID is
    seedance-2.5-x-r2v. It supports image-to-video, accepts text, image and
    video inputs, and returns results through asynchronous video tasks. The
    current APIPod model catalog marks it as beta.
servers:
  - url: https://api.apipod.ai
    description: Production
security: []
paths:
  /v1/videos/generations:
    post:
      tags:
        - Seedance 2.5 X Reference to Video
      summary: Create Generation Task
      description: >-
        Seedance 2.5 X Reference to Video is the lowest-cost multimodal route in
        APIPod's Seedance 2.5 family, billed per second. It combines up to 30
        reference images, 10 videos and 10 audios into a 5-30 second 720p video
        in eight aspect ratios; audio must be paired with at least one image or
        video, and reference video duration is billed together with the output
        duration. First/last-frame image-to-video is not offered on this tier
        because the upstream has no dedicated frame fields. In APIPod, the
        public model ID is seedance-2.5-x-r2v. It supports image-to-video,
        accepts text, image and video inputs, and returns results through
        asynchronous video tasks. The current APIPod model catalog marks it as
        beta.
      operationId: create-seedance-2-5-x-reference-to-video
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: Seedance 2.5 Reference to Video
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: seedance-2.5-x-r2v
                prompt:
                  type: string
                  title: Prompt
                  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.
                  maxLength: 30000
                  minLength: 1
                image_urls:
                  type: array
                  title: Image Urls
                  description: >-
                    Reference image URLs (up to 30). Real-person images are
                    supported.
                  items:
                    type: string
                    format: uri
                  maxItems: 30
                video_urls:
                  type: array
                  title: Video Urls
                  description: >-
                    Reference video URLs (up to 10). Reference video length is
                    billed on top of the output duration.
                  items:
                    type: string
                    format: uri
                  maxItems: 10
                audio_urls:
                  type: array
                  title: Audio Urls
                  description: >-
                    Reference audio URLs (up to 10). Audio cannot be used alone;
                    include at least one image or video reference.
                  items:
                    type: string
                    format: uri
                  maxItems: 10
                duration:
                  type: integer
                  title: Duration
                  description: Video duration in seconds (5-30).
                  enum:
                    - 5
                    - 6
                    - 7
                    - 8
                    - 9
                    - 10
                    - 11
                    - 12
                    - 13
                    - 14
                    - 15
                    - 16
                    - 17
                    - 18
                    - 19
                    - 20
                    - 21
                    - 22
                    - 23
                    - 24
                    - 25
                    - 26
                    - 27
                    - 28
                    - 29
                    - 30
                  default: 5
                  minimum: 5
                  maximum: 30
                resolution:
                  type: string
                  title: Resolution
                  description: Output resolution. Only 720p is available.
                  enum:
                    - 720p
                  default: 720p
                aspect_ratio:
                  type: string
                  title: Aspect Ratio
                  description: >-
                    Aspect ratio of the generated video: 1:1, 2:3, 3:2, 3:4,
                    4:3, 9:16, 16:9 or 21:9.
                  enum:
                    - '16:9'
                    - '9:16'
                    - '1:1'
                    - '4:3'
                    - '3:4'
                    - '21:9'
                    - '2:3'
                    - '3:2'
                  default: '16:9'
              required:
                - model
                - prompt
            example:
              model: seedance-2.5-x-r2v
              prompt: >-
                A cinematic tracking shot through a rain-soaked neon street,
                realistic motion, synchronized ambient sound.
              image_urls:
                - https://cdn.example.com/reference-1.jpg
              video_urls:
                - https://cdn.example.com/reference.mp4
              audio_urls:
                - https://cdn.example.com/reference.mp3
              duration: 5
              resolution: 720p
              aspect_ratio: '16:9'
      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.5-x-r2v",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "video_urls": [
                "https://cdn.example.com/reference.mp4"
              ],
              "audio_urls": [
                "https://cdn.example.com/reference.mp3"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }'
        - lang: Python
          label: Python
          source: |-
            import os
            import requests

            payload = {
              "model": "seedance-2.5-x-r2v",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "video_urls": [
                "https://cdn.example.com/reference.mp4"
              ],
              "audio_urls": [
                "https://cdn.example.com/reference.mp3"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }

            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.5-x-r2v",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "video_urls": [
                "https://cdn.example.com/reference.mp4"
              ],
              "audio_urls": [
                "https://cdn.example.com/reference.mp3"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }`), &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.5-x-r2v",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_urls": [
                "https://cdn.example.com/reference-1.jpg"
              ],
              "video_urls": [
                "https://cdn.example.com/reference.mp4"
              ],
              "audio_urls": [
                "https://cdn.example.com/reference.mp3"
              ],
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            });
                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.5-x-r2v",
                "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
                "image_urls": [
                  "https://cdn.example.com/reference-1.jpg"
                ],
                "video_urls": [
                  "https://cdn.example.com/reference.mp4"
                ],
                "audio_urls": [
                  "https://cdn.example.com/reference.mp3"
                ],
                "duration": 5,
                "resolution": "720p",
                "aspect_ratio": "16:9"
              }
              ),
            });


            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.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.