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

# Seedance Video Generation

> This document describes the input and output parameters of the Create Video Generation Task API for your reference when using the interface. The model generates videos based on the input images and text information. After generation is complete, you can query the task by conditions and obtain the generated video.

## Model Capabilities

* **Seedance 2.0 series (audio/silent videos)**
   * **Multimodal Reference-to-Video**：Input reference images (0-9) + reference videos (0-3) + reference audio (0-3) + text prompt (optional) to generate 1 target video. Note that audio cannot be input alone; at least 1 reference video or image must be included. Supports generating new videos, editing videos, and extending videos.
   * **Image-to-Video (First & Last Frame)**: Input first frame image + last frame image + text prompt (optional) to generate 1 target video.
   * **Image-to-Video (First Frame)**: Input first frame image + text prompt (optional) to generate 1 target video.
   * **Text-to-Video**：Input text prompt to generate 1 target video.

* **Seedance 1.5 pro（audio/silent videos)**
   【Image-to-Video (First & Last Frame), Image-to-Video (First Frame), Text-to-Video

* **Seedance 1.0 pro**
   【Image-to-Video (First & Last Frame), Image-to-Video (First Frame), Text-to-Video

* **Seedance 1.0 pro fast**
   【Image-to-Video (First Frame), Text-to-Video



## OpenAPI

````yaml api-reference/en/zmodelVideo/byteplus/seedance/seedance-video.json POST /byteplus/api/v3/contents/generations/tasks
openapi: 3.0.1
info:
  title: Seedance Video Generation
  version: 1.0.0
  description: >-
    This document describes the input and output parameters of the Create Video
    Generation Task API for your reference when using the interface. The model
    generates videos based on the input images and text information. After
    generation is complete, you can query the task by conditions and obtain the
    generated video.


    ## Model Capabilities


    * **Seedance 2.0 series (audio/silent videos)**
       * **Multimodal Reference-to-Video**：Input reference images (0-9) + reference videos (0-3) + reference audio (0-3) + text prompt (optional) to generate 1 target video. Note that audio cannot be input alone; at least 1 reference video or image must be included. Supports generating new videos, editing videos, and extending videos.
       * **Image-to-Video (First & Last Frame)**: Input first frame image + last frame image + text prompt (optional) to generate 1 target video.
       * **Image-to-Video (First Frame)**: Input first frame image + text prompt (optional) to generate 1 target video.
       * **Text-to-Video**：Input text prompt to generate 1 target video.

    * **Seedance 1.5 pro（audio/silent videos)**
       【Image-to-Video (First & Last Frame), Image-to-Video (First Frame), Text-to-Video

    * **Seedance 1.0 pro**
       【Image-to-Video (First & Last Frame), Image-to-Video (First Frame), Text-to-Video

    * **Seedance 1.0 pro fast**
       【Image-to-Video (First Frame), Text-to-Video
servers:
  - url: https://api.powertokens.ai
    description: Baze API server endpoint
security: []
paths:
  /byteplus/api/v3/contents/generations/tasks:
    post:
      summary: Create Video Generation Task
      description: >-
        This document describes the input and output parameters of the Create
        Video Generation Task API for your reference when using the interface.
        The model generates videos based on the input images and text
        information. After generation is complete, you can query the task by
        conditions and obtain the generated video.


        ## Model Capabilities


        * **Seedance 2.0 series (audio/silent videos)**
           * **Multimodal Reference-to-Video**：Input reference images (0-9) + reference videos (0-3) + reference audio (0-3) + text prompt (optional) to generate 1 target video. Note that audio cannot be input alone; at least 1 reference video or image must be included. Supports generating new videos, editing videos, and extending videos.
           * **Image-to-Video (First & Last Frame)**: Input first frame image + last frame image + text prompt (optional) to generate 1 target video.
           * **Image-to-Video (First Frame)**: Input first frame image + text prompt (optional) to generate 1 target video.
           * **Text-to-Video**：Input text prompt to generate 1 target video.

        * **Seedance 1.5 pro（audio/silent videos)**
           【Image-to-Video (First & Last Frame), Image-to-Video (First Frame), Text-to-Video

        * **Seedance 1.0 pro**
           【Image-to-Video (First & Last Frame), Image-to-Video (First Frame), Text-to-Video

        * **Seedance 1.0 pro fast**
           【Image-to-Video (First Frame), Text-to-Video
      operationId: createSeedanceVideoTask
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateVideoTaskRequest'
            examples:
              Multimodal Reference-to-Video:
                value:
                  model: dreamina-seedance-2-0-260128
                  content:
                    - type: text
                      text: >-
                        Use the first-person composition of video 1 throughout,
                        with audio 1 as background music throughout.
                        First-person fruit tea promotional ad, seedance brand
                        "Peace & Sweet" Apple Fruit Tea Limited Edition; First
                        frame is image 1, your hand picks an Aksu red apple with
                        morning dew, crisp apple crunch sound; 2-4s: Quick cut,
                        your hand throws apple chunks into a shaker, adds ice
                        and tea base, shakes vigorously, ice clinking and
                        shaking sounds sync with upbeat drum beats, background
                        audio: "Freshly Cut, Freshly Shaken"; 4-6s: First-person
                        product close-up, layered fruit tea poured into a clear
                        cup, your hand gently spreads cream cheese topping,
                        sticks a pink-gold label on the cup, camera zooms in on
                        the layered texture of cream and fruit tea; 6-8s:
                        First-person hand holding the cup, you raise the fruit
                        tea from image 2 to the camera (simulating handing it to
                        the viewer), cup label clearly visible, background audio
                        "Take a Fresh Sip", final frame frozen on image 2. All
                        background audio uses a female voice.
                    - type: image_url
                      image_url:
                        url: >-
                          https://ark-project.tos-cn-beijing.volces.com/doc_image/r2v_tea_pic1.jpg
                      role: reference_image
                    - type: image_url
                      image_url:
                        url: >-
                          https://ark-project.tos-cn-beijing.volces.com/doc_image/r2v_tea_pic2.jpg
                      role: reference_image
                    - type: video_url
                      video_url:
                        url: >-
                          https://ark-project.tos-cn-beijing.volces.com/doc_video/r2v_tea_video1.mp4
                      role: reference_video
                    - type: audio_url
                      audio_url:
                        url: >-
                          https://ark-project.tos-cn-beijing.volces.com/doc_audio/r2v_tea_audio1.mp3
                      role: reference_audio
                  generate_audio: true
                  ratio: '16:9'
                  duration: 11
                  watermark: false
              Audio Video - First Frame:
                value:
                  model: seedance-1-5-pro-251215
                  content:
                    - type: text
                      text: >-
                        A girl holding a fox, the girl opens her eyes and looks
                        gently at the camera, the fox holds her affectionately,
                        the camera slowly pulls out, the girl's hair blows in
                        the wind, wind sounds can be heard
                    - type: image_url
                      image_url:
                        url: >-
                          https://ark-project.tos-cn-beijing.volces.com/doc_image/i2v_foxrgirl.png
                  generate_audio: true
                  ratio: adaptive
                  duration: 5
                  watermark: false
              Audio Video - First & Last Frame:
                value:
                  model: seedance-1-5-pro-251215
                  content:
                    - type: text
                      text: >-
                        The girl in the picture says "Cheese" to the camera,
                        with a 360-degree orbiting camera movement
                    - type: image_url
                      image_url:
                        url: >-
                          https://ark-project.tos-cn-beijing.volces.com/doc_image/seepro_first_frame.jpeg
                      role: first_frame
                    - type: image_url
                      image_url:
                        url: >-
                          https://ark-project.tos-cn-beijing.volces.com/doc_image/seepro_last_frame.jpeg
                      role: last_frame
                  generate_audio: true
                  ratio: adaptive
                  duration: 5
                  watermark: false
              Image-to-Video - Base64:
                value:
                  model: dreamina-seedance-2-0-260128
                  content:
                    - type: text
                      text: >-
                        A girl holding a fox, the girl opens her eyes and looks
                        gently at the camera, the fox holds her affectionately,
                        the camera slowly pulls out, the girl's hair blows in
                        the wind
                    - type: image_url
                      image_url:
                        url: data:image/png;base64,aHR0******cG5n
                  ratio: adaptive
                  duration: 5
                  watermark: false
              Text-to-Video:
                value:
                  model: seedance-1-0-pro-250528
                  content:
                    - type: text
                      text: >-
                        Realistic style, under a clear blue sky, a large field
                        of white daisies, the camera gradually zooms in, finally
                        focused on a close-up of a daisy, with crystal clear
                        dewdrops on the petals
                  ratio: '16:9'
                  duration: 5
                  watermark: false
      responses:
        '200':
          description: Submission successful, returns video task object.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VideoTaskResponse'
        '400':
          description: Invalid request parameters.
        '401':
          description: Authentication failed.
        '429':
          description: Request rate limit exceeded.
        '500':
          description: Internal server error.
      security:
        - BearerAuth: []
components:
  schemas:
    CreateVideoTaskRequest:
      type: object
      required:
        - model
        - content
      properties:
        model:
          type: string
          enum:
            - seedance-1-5-pro-251215
            - seedance-1-0-pro-250528
            - seedance-1-0-pro-fast-251015
            - dreamina-seedance-2-0-260128
            - dreamina-seedance-2-0-fast-260128
            - dreamina-seedance-2-0-mini-260615
          description: The ID of the model you need to call (Model ID)
        content:
          type: array
          description: >-
            Input information for the model to generate videos. Supports text,
            images, audio, video, and draft task IDs.


            Note: Seedance 2.0 series models do not support directly uploading
            reference images/videos containing real human faces. To facilitate
            creators' use of portraits, the platform provides the following
            solutions:


            * Supports using face-containing raw outputs from certain models as
            input materials

            * Supports using preset virtual avatars as input materials

            * Supports using authorized real-person materials as input


            Supports the following combinations:

            * Text

            * Text (optional) + Image

            * Text (optional) + Video

            * Text (optional) + Image + Audio

            * Text (optional) + Image + Video

            * Text (optional) + Video + Audio

            * Text (optional) + Image + Video + Audio

            * Draft task ID: A draft refers to a sample video successfully
            generated using the Seedance model. The model can generate
            high-quality final videos based on the draft.


            ---
          items:
            oneOf:
              - $ref: '#/components/schemas/TextContent'
              - $ref: '#/components/schemas/ImageContent'
              - $ref: '#/components/schemas/VideoContent'
              - $ref: '#/components/schemas/AudioContent'
              - $ref: '#/components/schemas/DraftTaskContent'
            discriminator:
              propertyName: type
              mapping:
                text:
                  $ref: '#/components/schemas/TextContent'
                image_url:
                  $ref: '#/components/schemas/ImageContent'
                video_url:
                  $ref: '#/components/schemas/VideoContent'
                audio_url:
                  $ref: '#/components/schemas/AudioContent'
                draft_task:
                  $ref: '#/components/schemas/DraftTaskContent'
        callback_url:
          type: string
          description: >-
            The callback notification URL for the generation task results. When
            the video generation task status changes, the platform will send a
            POST request to this URL.


            The callback request body structure is the same as the query task
            API response.


            The callback status includes the following states:

            * queued: In queue.

            * running: Task running.

            * succeeded: Task successful. (If sending fails, i.e., no successful
            delivery within 5 seconds, retry up to 3 times)

            * failed: Task failed. (If sending fails, i.e., no successful
            delivery within 5 seconds, retry up to 3 times)

            * expired: Task timed out, meaning the task has been in running or
            queued state beyond the expiration time. Can be configured via the
            execution_expires_after field.
        return_last_frame:
          type: boolean
          description: >-
            true: Return the last frame image of the generated video. When set
            to true, you can obtain the last frame image through the query video
            generation task API. The last frame image is in PNG format with the
            same pixel dimensions as the generated video, without watermarks.


            Use this parameter to generate multiple consecutive videos: use the
            last frame of one video as the first frame of the next video task to
            quickly generate a sequence of consecutive videos.


            false: Do not return the last frame image of the generated video.
          default: false
        service_tier:
          type: string
          enum:
            - default
            - flex
          description: >-
            > The service tier of a submitted task cannot be modified

            > Seedance 2.0 series only supports online inference mode and does
            not support this parameter

            Currently offline inference is not yet supported


            Specifies the service tier for processing this request. Enum values:


            * default: Online inference mode, lower RPM and concurrency quotas,
            suitable for scenarios requiring low-latency inference.

            * flex: Offline inference mode, higher TPD quotas, priced at 50% of
            online inference, suitable for scenarios with less stringent latency
            requirements.
          default: default
        execution_expires_after:
          type: integer
          description: >-
            Task timeout threshold. Specifies the expiration time after task
            submission (in seconds), calculated from the created_at timestamp.
            Default: 172800 seconds (48 hours). Range: [3600, 259200].


            Regardless of the service_tier used, it is recommended to set an
            appropriate timeout based on your business scenario. After this
            time, the task will be automatically terminated and marked as
            expired.
          default: 172800
          minimum: 3600
          maximum: 259200
        generate_audio:
          type: boolean
          description: >-
            > Only supported by Seedance 2.0 series and Seedance 1.5 pro


            Controls whether the generated video contains synchronized audio.


            * true: The model outputs video with synchronized audio. The model
            automatically generates matching voice, sound effects, and
            background music based on the text prompt and visual content. It is
            recommended to place dialogue in double quotes for better audio
            generation. For example: The man stops the woman and says,
            "Remember, never point your finger at the moon."

            * false: The model outputs video without audio.


            Note: Generated audio videos are all mono, regardless of the input
            audio channel count.
          default: true
        draft:
          type: boolean
          description: >-
            > Only supported by Seedance 1.5 pro


            Controls whether to enable draft mode.


            * true: Enable draft mode to generate a preview video, quickly
            verifying whether the scene structure, camera movement, subject
            actions, and prompt intent meet expectations. Consumes fewer tokens
            than normal video, reducing cost.

            * false: Disable draft mode and generate a normal video.


            Note: When draft mode is enabled, Draft videos are generated at 480p
            resolution (using other resolutions will cause an error). The last
            frame return feature is not supported, and offline inference is not
            supported.
          default: false
        tools:
          type: array
          description: >-
            > Only supported by Seedance 2.0 series


            Configure the tools for the model to call. (Web search is currently
            not supported on overseas nodes)
          items:
            $ref: '#/components/schemas/Tool'
        safety_identifier:
          type: string
          description: >-
            Unique identifier of end users, used to help the platform detect
            users in your application who may violate the ModelArk usage policy.
            This identifier is an English string, which must be fixed and unique
            for a single user, and the length cannot exceed 64 characters. It is
            recommended to pass in a string generated by hashing the username,
            user ID or email address to avoid leaking user privacy information.
          maxLength: 64
        priority:
          type: integer
          description: >-
            > Only supported by Seedance 2.0 series. (Please contact sales for
            the maximum priority available per user)


            Sets the execution priority of the current request, determining its
            position in the queue. Range: 0~9, higher values indicate higher
            priority.


            By default, requests are executed in FIFO (First In, First Out)
            order. When a higher priority is set, the request will jump ahead of
            all lower-priority requests under the same Endpoint.


            Notes:

            * Requests with the same priority are still ordered by FIFO.

            * Priority only affects queue order and does not interrupt currently
            running (status=running) tasks.

            * Priority only takes effect within the same Endpoint and does not
            affect other Endpoints.

            * Offline inference mode (service_tier=flex) does not support
            priority configuration.


            **Example**:


            An Endpoint currently has 3 queued (status=queued) tasks in the
            queue, all with priority 0 (default).


            Queue: [Task A: priority=0] → [Task B: priority=0] → [Task C:
            priority=0]


            When a new request with priority=5 is submitted, it goes directly to
            the front of the queue:


            Queue: [New Request: priority=5] → [Task A: priority=0] → [Task B:
            priority=0] → [Task C: priority=0]
          default: 0
          minimum: 0
          maximum: 9
        resolution:
          type: string
          enum:
            - 480p
            - 720p
            - 1080p
            - 4k
          description: >-
            > Seedance 2.0 series and Seedance 1.5 pro default: `720p`

            > Seedance 1.0 pro & pro-fast default: `1080p`


            Video resolution. Enum values:


            * 480p

            * 720p

            * 1080p: Not supported by Seedance 2.0 Fast and Seedance 2.0 Mini.

            * 4k: Only supported by Seedance 2.0


            ```Note

            - Compared to typical 8-bit color depth, Seedance 2.0 4k output uses
            10-bit encoding, fully preserving rich color gradations and smooth
            transitions, meeting professional film production and HDR video
            content requirements.

            - 4k videos are output in H.265 (HEVC) format; some players/browsers
            may not support direct playback.
        ratio:
          type: string
          enum:
            - '16:9'
            - '4:3'
            - '1:1'
            - '3:4'
            - '9:16'
            - '21:9'
            - adaptive
          description: >-
            > Seedance 2.0 series and Seedance 1.5 pro default: `adaptive`

            > Other models: Text-to-Video default `16:9`, Image-to-Video default
            `adaptive`


            The aspect ratio of the generated video. See the table below for
            pixel dimensions for different aspect ratios.


            * 16:9

            * 4:3

            * 1:1

            * 3:4

            * 9:16

            * 21:9

            * adaptive: Automatically selects the most suitable aspect ratio
            based on input (see details below)


            **adaptive Rules**


            When ratio is set to adaptive, the model automatically adjusts the
            aspect ratio based on the generation scenario. The actual video
            aspect ratio can be obtained from the ratio field returned by the
            query video generation task API.


            ****Supported models:

            * Seedance 2.0 series, Seedance 1.5 Pro supported

            * Other models only supported in Image-to-Video scenarios


            ****Rules:

            * Text-to-Video：Based on the input prompt, intelligently selects the
            most suitable aspect ratio.

            * First Frame / First & Last Frame: Automatically selects the
            closest aspect ratio based on the uploaded first frame image ratio.

            * Multimodal Reference-to-Video: Determines based on user prompt
            intent. If it is first-frame video/editing video/extending video,
            selects the closest aspect ratio based on that image/video;
            otherwise, selects the closest aspect ratio based on the first media
            file (priority: video > image).


            Pixel dimensions corresponding to different aspect ratios


            Note: For Image-to-Video, if the selected aspect ratio does not
            match the uploaded image ratio, the platform will crop your image
            from the center.


            | Resolution | Aspect Ratio | Pixel Dimensions Seedance 2.0 Series |
            Pixel Dimensions Seedance 1.5 pro | Pixel Dimensions Seedance 1.0
            Series |

            |---|---|---|---|---|

            | 480p | 16:9 | 864×496 | 864×496 | 864×480 |

            | | 4:3 | 752×560 | 752×560 | 736×544 |

            | | 1:1 | 640×640 | 640×640 | 640×640 |

            | | 3:4 | 560×752 | 560×752 | 544×736 |

            | | 9:16 | 496×864 | 496×864 | 480×864 |

            | | 21:9 | 992×432 | 992×432 | 960×416 |

            | 720p | 16:9 | 1280×720 | 1280×720 | 1248×704 |

            | | 4:3 | 1112×834 | 1112×834 | 1120×832 |

            | | 1:1 | 960×960 | 960×960 | 960×960 |

            | | 3:4 | 834×1112 | 834×1112 | 832×1120 |

            | | 9:16 | 720×1280 | 720×1280 | 704×1248 |

            | | 21:9 | 1470×630 | 1470×630 | 1504×640 |

            | 1080p (Not supported by Seedance 2.0 Fast, Seedance 2.0 Mini)|
            16:9 | 1920×1080 | 1920×1080 | 1920×1088 |

            | | 4:3 | 1664×1248 | 1664×1248 | 1664×1248 |

            | | 1:1 | 1440×1440 | 1440×1440 | 1440×1440 |

            | | 3:4 | 1248×1664 | 1248×1664 | 1248×1664 |

            | | 9:16 | 1080×1920 | 1080×1920 | 1088×1920 |

            | | 21:9 | 2206×946 | 2206×946 | 2176×928 |

            | 4K (Only supported by Seedance 2.0) | 16:9 | 3840×2160 | - | - |

            | | 4:3 | 3326×2494 | - | - |

            | | 1:1 | 2880×2880 | - | - |

            | | 3:4 | 2494×3326 | - | - |

            | | 9:16 | 2160×3840 | - | - |

            | | 21:9 | 4398×1886 | - | - |
        duration:
          type: integer
          description: >-
            Video duration, integer only, in seconds.


            * Seedance 1.0 pro, Seedance 1.0 pro fast: [2, 12] s.

            * Seedance 1.5 pro: [4, 12] or set to -1

            * Seedance 2.0 series: [4, 15] or set to -1


            **Note**


            Seedance 2.0 series and Seedance 1.5 pro support two configuration
            methods:

            * Specify exact duration: Any integer within the valid range.

            * Smart mode: Set to -1 to let the model choose the appropriate
            video length (in whole seconds) within the valid range. The actual
            generated video duration can be obtained from the duration field
            returned by the query video generation task API. Note that video
            duration is related to billing, so set it carefully.
          default: 5
          minimum: -1
          maximum: 15
        frames:
          type: integer
          description: >-
            > Temporarily not supported by Seedance 2.0 series and Seedance 1.5
            pro

            > Choose either duration or frames; frames takes priority over
            duration. If you want to generate videos with fractional seconds, it
            is recommended to specify frames.


            The number of frames for the generated video. By specifying the
            frame count, you can flexibly control the video length and generate
            videos with fractional seconds.


            Due to frames value constraints, only limited fractional seconds are
            supported. You need to calculate the closest frame count using the
            formula.


            * Formula: frames = duration x frame rate (24).

            * Range: Supports all integer values in the [29, 289] range that
            satisfy the format 25 + 4n, where n is a positive integer.


            Example: To generate a 2.4-second video, frames = 2.4 x 24 = 57.6.
            Since frames does not support 57.6, you can only choose the closest
            value. According to 25+4n, the closest frame count is 57, and the
            actual generated video is 57/24 = 2.375 seconds.
          minimum: 29
          maximum: 289
        seed:
          type: integer
          description: >-
            > Temporarily not supported by Seedance 2.0 series


            Seed integer for controlling the randomness of generated content.
            Range: integer in [-1, 2^32-1].


            Notes:

            * With the same request, if the model receives different seed values
            (e.g., not specifying a seed, setting seed to -1 which uses a random
            number, or manually changing the seed value), different results will
            be generated.

            * With the same request, if the model receives the same seed value,
            similar results will be generated, but exact consistency is not
            guaranteed.
          default: -1
          minimum: -1
          maximum: 4294967295
        camera_fixed:
          type: boolean
          description: >-
            > Not supported in reference image scenarios, temporarily not
            supported by Seedance 2.0 series


            Whether to fix the camera.


            * true: Fix the camera. The platform will append fixed camera
            instructions to the user prompt, but the actual effect is not
            guaranteed.

            * false: Do not fix the camera.
          default: false
        watermark:
          type: boolean
          description: >-
            Whether the generated video contains a watermark.


            * false: The generated video does not contain a watermark.

            * true: The generated video displays an "AI Generated" watermark in
            the bottom-right corner.
          default: false
    VideoTaskResponse:
      type: object
      properties:
        id:
          type: string
          description: >-
            Video generation task ID. Only stored for 7 days (from the
            `created_at` timestamp), then automatically deleted.


            * When draft: true, this is the Draft video task ID.

            * When draft: false, this is the normal video task ID.


            Video generation is asynchronous. After obtaining the ID, use the
            query video generation task API to check the status. When
            successful, the API returns the generated video URL.
    TextContent:
      title: Text Content
      type: object
      required:
        - type
        - text
      properties:
        type:
          type: string
          enum:
            - text
          description: The type of input content. This should be text.
        text:
          type: string
          description: >-
            Text prompt input to the model, describing the expected video
            content.


            Notes:

            * Prompt language support: All models support Chinese and English
            prompts; seedance 2.0 and seedance 2.0 fast additionally support
            Japanese, Indonesian, Spanish, and Portuguese.

            * Prompt length recommendations: Chinese prompts should not exceed
            500 characters, English prompts should not exceed 1000 words.
            Excessively long prompts may cause information dispersion, and the
            model may ignore details and only focus on key points, resulting in
            missing elements in the video.
      description: Prompt information input to the model.
    ImageContent:
      title: Image Content
      type: object
      required:
        - type
        - image_url
      properties:
        type:
          type: string
          enum:
            - image_url
          description: The type of input content. This should be image_url.
        image_url:
          type: object
          required:
            - url
          description: The image object input to the model.
          properties:
            url:
              type: string
              description: >-
                Image URL, Base64-encoded image, or asset ID.


                * Image URL: Provide the public URL of the image.

                * Base64 encoding: Convert local files to a Base64-encoded
                string and submit it to the model. Format:
                data:image/<image_format>;base64,<Base64_encoding>. Note that
                <image_format> must be lowercase, e.g.,
                data:image/png;base64,{base64_image}.

                * Asset ID: The ID of preset assets and virtual avatars for
                video generation. Format: asset://<ASSET_ID>. Can be obtained
                from the Assets & Virtual Avatars library.


                Single image requirements:

                * Formats: jpeg, png, webp, bmp, tiff, gif. Seedance 1.5 pro and
                Seedance 2.0 series additionally support heic and heif.

                * Aspect ratio (width/height): (0.4, 2.5)

                * Dimensions (px): (300, 6000)

                * Size: Single image under 30 MB. Request body size does not
                exceed 64 MB. Do not use Base64 encoding for large files.

                * Image count:
                   * Image-to-Video (First Frame): 1 image
                   * Image-to-Video (First & Last Frame): 2 images
                   * Seedance 2.0 series Multimodal Reference-to-Video: 1-9 images
        role:
          type: string
          enum:
            - first_frame
            - last_frame
            - reference_image
          description: >-
            The position or purpose of the image. Conditionally required.


            Note:

            * Image-to-Video (First Frame), Image-to-Video (First & Last Frame),
            and Multimodal Reference-to-Video (including reference images,
            videos, and audio) are 3 mutually exclusive scenarios and cannot be
            mixed.

            * Multimodal Reference-to-VideoYou can specify reference images as
            first/last frames through prompts to indirectly achieve "First &
            Last Frame + Multimodal Reference" effects. If you need strict
            consistency between the first/last frames and specified images,
            prioritize using Image-to-Video (First & Last Frame) with role set
            to first_frame/last_frame.


            Image-to-Video (First Frame):

            * Supported models: All models

            * Field role value: Requires 1 image_url object, with role set to
            first_frame or left empty.


            Image-to-Video (First & Last Frame):

            * Supported models: Seedance 2.0 series, Seedance 1.5 pro, Seedance
            1.0 pro

            * Field role value: Requires 2 image_url objects, and the role field
            is required.

               * The role for the first frame image is: first_frame

               * The role for the last frame image is: last_frame

            Note: The first and last frame images can be the same. If the aspect
            ratios of the first and last frame images differ, the first frame
            image takes priority, and the last frame image will be automatically
            cropped to fit.


            Image-to-Video (Reference Image):

            * Supported models: Seedance 2.0 series (1~9 images)

            * Field role value: Required. The role for each reference image is:
            reference_image
      description: Image information input to the model.
    VideoContent:
      title: Video Content
      type: object
      required:
        - type
        - video_url
      properties:
        type:
          type: string
          enum:
            - video_url
          description: The type of input content. This should be video_url.
        video_url:
          type: object
          required:
            - url
          description: The video object input to the model.
          properties:
            url:
              type: string
              description: >-
                Video URL or Asset ID.


                * Video URL: Enter the public URL of the video.

                * Asset ID: ID for preset assets and virtual avatar videos used
                in video generation, format: asset://<ASSET_ID>. Can be obtained
                from the Assets & Virtual Avatars Library.


                Single video requirements:

                * Formats: mp4, mov. Supported codecs are listed below.

                * Resolution: 480p, 720p, 1080p

                * Duration: Single video [2, 15] s, up to 3 reference videos,
                total duration must not exceed 15s.

                * Dimensions:
                   * Aspect ratio (width/height): [0.4, 2.5]
                   * Width/height (px): [300, 6000]
                   * Total pixels: [640x640=409600, 2206x946=2086876], i.e., width x height must be within [409600, 2086876].
                * Size: Single video must not exceed 50 MB.

                * Frame rate (FPS): [24, 60]


                Supported codecs:

                | Container | Common Extensions | MIME | Supported Codecs |

                |---|---|---|---|

                | MP4 | .mp4 | video/mp4 | Video: H.264/AVC, H.265/HEVC; Audio:
                AAC, MP3 |

                | QuickTime | .mov | video/quicktime | Video: H.264/AVC,
                H.265/HEVC; Audio: AAC, MP3 |
        role:
          type: string
          enum:
            - reference_video
          description: >-
            The position or purpose of the video. Currently only supports
            reference_video. Required under certain conditions.
      description: >-
        Video information input to the model. Only the Seedance 2.0 series
        supports video input.
    AudioContent:
      title: Audio Content
      type: object
      required:
        - type
        - audio_url
      properties:
        type:
          type: string
          enum:
            - audio_url
          description: >-
            The type of input content. This should be audio_url. Only the
            Seedance 2.0 series supports audio input. Note that audio cannot be
            input alone; at least 1 reference video or image must be included.
        audio_url:
          type: object
          required:
            - url
          description: >-
            The audio object input to the model. Only the Seedance 2.0 series
            supports audio input.
          properties:
            url:
              type: string
              description: >-
                Audio URL, Audio Base64 encoding, or Asset ID.


                * Audio URL: Enter the public URL of the audio.

                * Base64 encoding: Convert a local file to a Base64-encoded
                string and submit it to the model. Format:
                data:audio/<audio_format>;base64,<Base64_encoding>. Note that
                <audio_format> must be lowercase, e.g.,
                data:audio/wav;base64,{base64_audio}.

                * Asset ID: ID for virtual avatar audio assets used in video
                generation, format: asset://<ASSET_ID>. Can be obtained from the
                Assets & Virtual Avatars Library.


                Single audio requirements:

                * Formats: wav, mp3

                * Duration: Single audio [2, 15] s, up to 3 reference audio
                segments, total duration must not exceed 15s.

                * Size: Single audio must not exceed 15 MB, request body size
                must not exceed 64 MB. Do not use Base64 encoding for large
                files.
        role:
          type: string
          enum:
            - reference_audio
          description: >-
            The position or purpose of the audio. Currently only supports
            reference_audio. Required under certain conditions.
      description: >-
        Audio information input to the model. Only the Seedance 2.0 series
        supports audio input. Note that audio cannot be input alone; at least 1
        reference video or image must be included.
    DraftTaskContent:
      title: Draft Task Content
      type: object
      required:
        - type
        - draft_task
      properties:
        type:
          type: string
          enum:
            - draft_task
          description: The type of input content. This should be draft_task.
        draft_task:
          type: object
          required:
            - id
          description: Draft task object input to the model.
          properties:
            id:
              type: string
              description: >-
                Draft task ID. The platform will automatically reuse the user
                input from the Draft video (model, content.text,
                content.image_url, generate_audio, seed, ratio, duration,
                camera_fixed) to generate the final video. Other parameters can
                be specified; if not specified, the model defaults will be used.


                Usage is a two-step process: Step 1: Call this endpoint to
                generate a Draft video. Step 2: If the Draft video meets
                expectations, call this endpoint again with the Draft video task
                ID from Step 1 to generate the final video.
      description: >-
        Generate the final video based on the draft task ID. Only supported by
        Seedance 1.5 Pro.
    Tool:
      type: object
      required:
        - type
      properties:
        type:
          type: string
          enum:
            - web_search
          description: >-
            Specifies the type of tool to use.


            * web_search: Web search tool.


            Notes:

            * When web search is enabled, the model autonomously determines
            whether to search internet content (e.g., products, weather) based
            on the user prompt. This can improve the timeliness of generated
            videos but may increase latency.

            * The actual number of searches can be obtained from the
            usage.tool_usage.web_search field in the query video generation task
            API response. A value of 0 indicates no search was performed.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: 'Pass `Authorization: Bearer <token>` in the request header.'

````