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

# Flux 3 비디오 생성

> 텍스트, 참조 이미지 또는 첫 번째와 마지막 프레임으로 720p 또는 1080p 크기 사전 설정의 Flux 3 비디오를 생성합니다.

텍스트, 참조 이미지 또는 첫 번째와 마지막 프레임으로 Flux 3 비디오를 생성합니다. 반환된 `id`을 저장하여 작업 상태를 폴링하고 완료된 비디오를 다운로드하세요.

`POST /v1/videos` `multipart/form-data`을 사용합니다. 제어값은 양식 필드로 전송하세요. 이미지 입력에는 참조 이미지 URL 또는 시작 및 종료 프레임을 사용하세요.

`input_reference`을 `first_frame` 및 `last_frame`과 별도로 유지하세요.

## 입력 모드 선택

| 목표                  | 필수 필드                                                    | 선택적 필드            |
| ------------------- | -------------------------------------------------------- | ----------------- |
| 텍스트-비디오 변환          | `model=flux-3`, `prompt`                                 | `seconds`, `size` |
| HTTPS 이미지-비디오 변환    | `model=flux-3`, `prompt`, `input_reference` URL 하나       | `seconds`, `size` |
| 순서가 지정된 키프레임        | `model=flux-3`, `prompt`, `input_reference` URL을 반복하여 지정 | `seconds`, `size` |
| 업로드된 시작 프레임         | `model=flux-3`, `prompt`, `first_frame` 파일 하나            | `seconds`, `size` |
| 첫 프레임 및 마지막 프레임 비디오 | `model=flux-3`, `prompt`, `first_frame`, `last_frame`    | `seconds`, `size` |

## 참조 이미지 사용

`input_reference` 필드는 공개적으로 액세스 가능한 HTTPS 이미지 URL만 허용합니다. 이미지가 하나이면 한 번 전송하고, 여러 이미지이면 키프레임 순서대로 반복하여 전송하세요. 필드당 URL 하나를 사용하며, 총 최대 10개의 URL을 사용할 수 있습니다.

생성된 비디오가 참조 이미지에서 유지해야 하는 움직임, 카메라 동작 및 시각적 세부 사항을 설명하세요.

이 페이지 상단의 요청 샘플은 단일 이미지 및 다중 이미지 입력을 보여 줍니다. 다음 요청은 제출된 순서대로 두 이미지를 사용합니다:

```bash theme={null}
curl \
  https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  --form-string 'model=flux-3' \
  --form-string 'prompt=Move smoothly through the supplied reference images in their given order. Preserve recognizable subjects and visual details as the scene changes. Keep the camera movement gentle.' \
  --form-string 'seconds=5' \
  --form-string 'size=1280x720' \
  --form-string 'input_reference=https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png' \
  --form-string 'input_reference=https://apidoc.cometapi.com/images/image/gemini/6100640_569420.png'
```

## 첫 번째와 마지막 프레임 설정

시작 이미지를 설정하려면 `first_frame`을 전송하세요. 종료 이미지도 설정하려면 `last_frame`을 포함하고, 두 프레임 사이의 움직임을 `prompt`에 설명하세요.

시작 프레임만 사용할 경우 `last_frame`을 생략하세요. 종료 프레임에는 `first_frame` 및 `last_frame`이 모두 필요합니다.

각 필드는 공개적으로 액세스 가능한 HTTPS URL 하나 또는 PNG나 JPEG 파일 하나를 허용합니다. URL 또는 파일 중 하나를 사용하여 각 필드를 한 번 전송하세요. 각 파일의 크기는 20 MiB(20 × 1024 × 1024바이트).

이 페이지 상단의 프레임 예시는 URL 입력과 파일 업로드를 보여 주며, `seconds` 및 `size`이 명시적으로 설정되어 있습니다.

## 길이 및 크기 설정

`seconds`을 `5`부터 `20`까지의 정수로 명시적으로 설정하세요.

`size`을 다음의 정확한 `WxH` 사전 설정 값 중 하나로 설정하세요:

| 해상도 등급  | 크기          |
| ------- | ----------- |
| `720p`  | `1280x720`  |
| `1080p` | `1920x1080` |

크기 값은 출력 해상도 등급을 선택합니다. 텍스트-비디오 변환의 경우 코덱 정렬을 위해 인코딩된 크기가 조정될 수 있습니다. 이미지-비디오 변환의 경우 참조 이미지가 최종 프레이밍과 종횡비를 결정할 수도 있습니다.

## 작업 흐름

<Steps>
  <Step title="작업 생성">
    멀티파트 양식 요청을 전송하고 반환된 `id`을 저장하세요.
  </Step>

  <Step title="작업 폴링">
    다음을 [Flux 3 비디오 조회](./retrieve) 를 `status`이 `completed` 또는 `failed`이 될 때까지 호출합니다.
  </Step>

  <Step title="결과 다운로드">
    작업이 `completed` 상태가 되면 다음을 호출하여 [Flux 3 비디오 콘텐츠 다운로드](./retrieve-content) MP4 파일을 저장합니다.
  </Step>
</Steps>


## OpenAPI

````yaml api/openapi/video/flux-3/post-create.openapi.json POST /v1/videos
openapi: 3.1.0
info:
  title: Flux 3 Video Create API
  version: 1.0.0
  description: >-
    Create a Flux 3 video from text, a reference image, or opening and closing
    frames with multipart form data.
servers:
  - url: https://api.cometapi.com
security:
  - bearerAuth: []
paths:
  /v1/videos:
    post:
      summary: Create a Flux 3 video task
      description: >-
        Create a Flux 3 video from text, one reference image URL, or opening and
        closing frames.
      operationId: flux_3_create_video
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Flux3CreateRequest'
            encoding:
              input_reference:
                contentType: text/plain
                style: form
                explode: true
              first_frame:
                contentType: image/png, image/jpeg, text/plain
              last_frame:
                contentType: image/png, image/jpeg, text/plain
            examples:
              text_to_video:
                summary: Text-to-video
                value:
                  model: flux-3
                  prompt: >-
                    A paper boat glides across a still pond while the camera
                    moves forward.
                  seconds: 5
                  size: 1280x720
              https_image_to_video:
                summary: Image-to-video with an HTTPS image
                value:
                  model: flux-3
                  prompt: >-
                    Animate the reference scene with a slow camera move and
                    natural motion.
                  seconds: 5
                  size: 1280x720
                  input_reference: >-
                    https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png
              first_last_frame_urls:
                summary: First and last frames from URLs
                value:
                  model: flux-3
                  prompt: Move smoothly from the opening to the closing scene.
                  seconds: 5
                  size: 1280x720
                  first_frame: https://your-image-host/first-frame.png
                  last_frame: https://your-image-host/last-frame.png
              first_last_frame_files:
                summary: First and last frames from files
                value:
                  model: flux-3
                  prompt: Move smoothly from the opening to the closing scene.
                  seconds: 5
                  size: 1280x720
                  first_frame: '@/path/to/first-frame.png'
                  last_frame: '@/path/to/last-frame.png'
              opening_frame_file:
                summary: Opening frame from a file
                value:
                  model: flux-3
                  prompt: >-
                    Animate the opening frame with a slow camera move and
                    natural motion.
                  seconds: 5
                  size: 1280x720
                  first_frame: '@/path/to/reference.png'
              input_reference_url_pair:
                summary: Ordered keyframes from image URLs
                value:
                  model: flux-3
                  prompt: >-
                    Move smoothly through the supplied reference images in their
                    given order. Preserve recognizable subjects and visual
                    details as the scene changes. Keep the camera movement
                    gentle.
                  seconds: 5
                  size: 1280x720
                  input_reference:
                    - >-
                      https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png
                    - >-
                      https://apidoc.cometapi.com/images/image/gemini/6100640_569420.png
      responses:
        '200':
          description: >-
            Task created. Store the returned id and poll GET
            /v1/videos/{task_id}.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Flux3VideoTask'
              example:
                id: <task_id>
                task_id: <task_id>
                object: video
                model: flux-3
                status: queued
                progress: 0
                created_at: 1779938152
        '400':
          description: >-
            The request is missing a required field or contains an unsupported
            value.
        '401':
          description: The API key is missing or invalid.
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: Shell
          label: Text-to-video
          source: |-
            curl \
              https://api.cometapi.com/v1/videos \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              --form-string 'model=flux-3' \
              --form-string 'prompt=A paper boat glides across a still pond while the camera moves forward.' \
              --form-string 'seconds=5' \
              --form-string 'size=1280x720'
        - lang: Python
          label: Text-to-video
          source: |
            import os

            import requests

            fields = [
                ("model", (None, "flux-3")),
                (
                    "prompt",
                    (
                        None,
                        "A paper boat glides across a still pond while the "
                        "camera moves forward.",
                    ),
                ),
                ("seconds", (None, "5")),
                ("size", (None, "1280x720")),
            ]

            response = requests.post(
                "https://api.cometapi.com/v1/videos",
                headers={
                    "Authorization": "Bearer " + os.environ["COMETAPI_KEY"]
                },
                files=fields,
                timeout=120,
            )
            response.raise_for_status()
            print(response.json())
        - lang: JavaScript
          label: Text-to-video
          source: |
            const form = new FormData();
            form.append("model", "flux-3");
            form.append(
              "prompt",
              "A paper boat glides across a still pond while the camera moves forward.",
            );
            form.append("seconds", "5");
            form.append("size", "1280x720");

            const response = await fetch("https://api.cometapi.com/v1/videos", {
              method: "POST",
              headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
              body: form,
            });

            if (!response.ok) {
              throw new Error(await response.text());
            }

            console.log(await response.json());
        - lang: Shell
          label: HTTPS image-to-video
          source: |-
            curl \
              https://api.cometapi.com/v1/videos \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              --form-string 'model=flux-3' \
              --form-string 'prompt=Animate the reference scene with a slow camera move and natural motion.' \
              --form-string 'seconds=5' \
              --form-string 'size=1280x720' \
              --form-string 'input_reference=https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png'
        - lang: Python
          label: HTTPS image-to-video
          source: |
            import os

            import requests

            fields = [
                ("model", (None, "flux-3")),
                (
                    "prompt",
                    (
                        None,
                        "Animate the reference scene with a slow camera move and "
                        "natural motion.",
                    ),
                ),
                ("seconds", (None, "5")),
                ("size", (None, "1280x720")),
                (
                    "input_reference",
                    (None, "https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png"),
                ),
            ]

            response = requests.post(
                "https://api.cometapi.com/v1/videos",
                headers={
                    "Authorization": "Bearer " + os.environ["COMETAPI_KEY"]
                },
                files=fields,
                timeout=120,
            )
            response.raise_for_status()
            print(response.json())
        - lang: JavaScript
          label: HTTPS image-to-video
          source: >
            const form = new FormData();

            form.append("model", "flux-3");

            form.append(
              "prompt",
              "Animate the reference scene with a slow camera move and natural motion.",
            );

            form.append("seconds", "5");

            form.append("size", "1280x720");

            form.append("input_reference",
            "https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png");


            const response = await fetch("https://api.cometapi.com/v1/videos", {
              method: "POST",
              headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
              body: form,
            });


            if (!response.ok) {
              throw new Error(await response.text());
            }


            console.log(await response.json());
        - lang: Shell
          label: First and last frames from URLs
          source: |-
            image1=https://your-image-host/first-frame.png
            image2=https://your-image-host/last-frame.png

            curl \
              https://api.cometapi.com/v1/videos \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              --form-string model=flux-3 \
              --form-string 'prompt=Move smoothly from the opening to the closing scene.' \
              --form-string seconds=5 \
              --form-string size=1280x720 \
              --form-string "first_frame=$image1" \
              --form-string "last_frame=$image2"
        - lang: Python
          label: First and last frames from URLs
          source: |
            import os

            import requests

            url1 = "https://your-image-host/first-frame.png"
            url2 = "https://your-image-host/last-frame.png"

            prompt = "Move smoothly from the opening to the closing scene."

            fields = [
                ("model", (None, "flux-3")),
                ("prompt", (None, prompt)),
                ("seconds", (None, "5")),
                ("size", (None, "1280x720")),
                (
                    "first_frame",
                    (None, url1),
                ),
                (
                    "last_frame",
                    (None, url2),
                ),
            ]

            response = requests.post(
                "https://api.cometapi.com/v1/videos",
                headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
                files=fields,
                timeout=120,
            )

            response.raise_for_status()
            print(response.json())
        - lang: JavaScript
          label: First and last frames from URLs
          source: >
            const form = new FormData();

            form.append("model", "flux-3");

            form.append("prompt", "Move smoothly from the opening to the closing
            scene.");

            form.append("seconds", "5");

            form.append("size", "1280x720");

            form.append(
              "first_frame",
              "https://your-image-host/first-frame.png",
            );

            form.append(
              "last_frame",
              "https://your-image-host/last-frame.png",
            );


            const response = await fetch("https://api.cometapi.com/v1/videos", {
              method: "POST",
              headers: { Authorization: "Bearer " + process.env.COMETAPI_KEY },
              body: form,
            });


            if (!response.ok) {
              throw new Error(await response.text());
            }


            console.log(await response.json());
        - lang: Shell
          label: First and last frames from files
          source: |-
            curl \
              https://api.cometapi.com/v1/videos \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              --form-string model=flux-3 \
              --form-string 'prompt=Move smoothly from the opening to the closing scene.' \
              --form-string seconds=5 \
              --form-string size=1280x720 \
              --form 'first_frame=@/path/to/first-frame.png;type=image/png' \
              --form 'last_frame=@/path/to/last-frame.png;type=image/png'
        - lang: Python
          label: First and last frames from files
          source: |
            import os
            from contextlib import ExitStack

            import requests

            prompt = (
                "Move smoothly from the opening to the closing scene."
            )

            with ExitStack() as stack:
                image_1 = stack.enter_context(open("/path/to/first-frame.png", "rb"))
                image_2 = stack.enter_context(open("/path/to/last-frame.png", "rb"))
                fields = [
                    ("model", (None, "flux-3")),
                    ("prompt", (None, prompt)),
                    ("seconds", (None, "5")),
                    ("size", (None, "1280x720")),
                    ("first_frame", ("first-frame.png", image_1, "image/png")),
                    ("last_frame", ("last-frame.png", image_2, "image/png")),
                ]

                response = requests.post(
                    "https://api.cometapi.com/v1/videos",
                    headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
                    files=fields,
                    timeout=120,
                )

            response.raise_for_status()
            print(response.json())
        - lang: JavaScript
          label: First and last frames from files
          source: >
            import { readFile } from "node:fs/promises";


            const image_1 = await readFile("/path/to/first-frame.png");

            const image_2 = await readFile("/path/to/last-frame.png");


            const form = new FormData();

            form.append("model", "flux-3");

            form.append("prompt", "Move smoothly from the opening to the closing
            scene.");

            form.append("seconds", "5");

            form.append("size", "1280x720");

            form.append(
              "first_frame",
              new Blob([image_1], { type: "image/png" }),
              "first-frame.png",
            );

            form.append(
              "last_frame",
              new Blob([image_2], { type: "image/png" }),
              "last-frame.png",
            );


            const response = await fetch("https://api.cometapi.com/v1/videos", {
              method: "POST",
              headers: { Authorization: "Bearer " + process.env.COMETAPI_KEY },
              body: form,
            });


            if (!response.ok) {
              throw new Error(await response.text());
            }


            console.log(await response.json());
        - lang: Shell
          label: Opening frame from a file
          source: |-
            curl \
              https://api.cometapi.com/v1/videos \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              --form-string 'model=flux-3' \
              --form-string 'prompt=Animate the opening frame with a slow camera move and natural motion.' \
              --form-string 'seconds=5' \
              --form-string 'size=1280x720' \
              --form 'first_frame=@/path/to/reference.png;type=image/png'
        - lang: Python
          label: Opening frame from a file
          source: |
            import os

            import requests

            prompt = (
                "Animate the opening frame with a slow camera move and "
                "natural motion."
            )

            with open("/path/to/reference.png", "rb") as reference:
                response = requests.post(
                    "https://api.cometapi.com/v1/videos",
                    headers={
                        "Authorization": "Bearer "
                        + os.environ["COMETAPI_KEY"]
                    },
                    data={
                        "model": "flux-3",
                        "prompt": prompt,
                        "seconds": "5",
                        "size": "1280x720",
                    },
                    files={
                        "first_frame": (
                            "reference.png",
                            reference,
                            "image/png",
                        )
                    },
                    timeout=120,
                )

            response.raise_for_status()
            print(response.json())
        - lang: JavaScript
          label: Opening frame from a file
          source: |
            import { readFile } from "node:fs/promises";

            const reference = await readFile("/path/to/reference.png");
            const form = new FormData();
            form.append("model", "flux-3");
            form.append(
              "prompt",
              "Animate the opening frame with a slow camera move and natural motion.",
            );
            form.append("seconds", "5");
            form.append("size", "1280x720");
            form.append(
              "first_frame",
              new Blob([reference], { type: "image/png" }),
              "reference.png",
            );

            const response = await fetch("https://api.cometapi.com/v1/videos", {
              method: "POST",
              headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
              body: form,
            });

            if (!response.ok) {
              throw new Error(await response.text());
            }

            console.log(await response.json());
        - lang: Shell
          label: Ordered keyframes from image URLs
          source: |-
            curl \
              https://api.cometapi.com/v1/videos \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              --form-string 'model=flux-3' \
              --form-string 'prompt=Move smoothly through the supplied reference images in their given order. Preserve recognizable subjects and visual details as the scene changes. Keep the camera movement gentle.' \
              --form-string 'seconds=5' \
              --form-string 'size=1280x720' \
              --form-string 'input_reference=https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png' \
              --form-string 'input_reference=https://apidoc.cometapi.com/images/image/gemini/6100640_569420.png'
        - lang: Python
          label: Ordered keyframes from image URLs
          source: |
            import os

            import requests

            fields = [
                ("model", (None, "flux-3")),
                ("prompt", (None, "Move smoothly through the supplied reference images in their given order. Preserve recognizable subjects and visual details as the scene changes. Keep the camera movement gentle.")),
                ("seconds", (None, "5")),
                ("size", (None, "1280x720")),
                ("input_reference", (None, "https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png")),
                ("input_reference", (None, "https://apidoc.cometapi.com/images/image/gemini/6100640_569420.png")),
            ]

            response = requests.post(
                "https://api.cometapi.com/v1/videos",
                headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
                files=fields,
                timeout=120,
            )
            response.raise_for_status()
            print(response.json())
        - lang: JavaScript
          label: Ordered keyframes from image URLs
          source: >
            const form = new FormData();

            form.append("model", "flux-3");

            form.append("prompt", "Move smoothly through the supplied reference
            images in their given order. Preserve recognizable subjects and
            visual details as the scene changes. Keep the camera movement
            gentle.");

            form.append("seconds", "5");

            form.append("size", "1280x720");

            form.append("input_reference",
            "https://apidoc.cometapi.com/images/image/gemini/6100640_569429.png");

            form.append("input_reference",
            "https://apidoc.cometapi.com/images/image/gemini/6100640_569420.png");


            const response = await fetch("https://api.cometapi.com/v1/videos", {
              method: "POST",
              headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
              body: form,
            });


            if (!response.ok) {
              throw new Error(await response.text());
            }


            console.log(await response.json());
components:
  schemas:
    Flux3CreateRequest:
      type: object
      description: >-
        Flux 3 multipart request. Choose text, input_reference URLs, or
        first_frame and last_frame inputs. Keep reference-image and frame inputs
        separate.
      required:
        - model
        - prompt
      not:
        anyOf:
          - required:
              - input_reference
              - first_frame
          - required:
              - input_reference
              - last_frame
      properties:
        model:
          type: string
          const: flux-3
          default: flux-3
          description: Model ID for this route. Use flux-3.
        prompt:
          type: string
          minLength: 1
          description: >-
            Text that describes the scene, motion, camera behavior, and visual
            details that the video should preserve.
          default: >-
            A paper boat glides across a still pond while the camera moves
            forward.
        seconds:
          type: integer
          minimum: 5
          maximum: 20
          description: >-
            Requested clip duration in whole seconds. Set seconds explicitly to
            an integer from 5 through 20.
        size:
          type: string
          enum:
            - 1280x720
            - 1920x1080
          default: 1280x720
          description: >-
            Resolution preset in exact WxH form. Use 1280x720 for the 720p tier
            or 1920x1080 for the 1080p tier. Encoded dimensions can be
            codec-aligned; image-to-video framing can follow the reference
            image.
        input_reference:
          description: >-
            Reference image URLs. Send one publicly accessible HTTPS image URL
            per input_reference field. For multiple images, repeat the field in
            keyframe order, up to 10 URLs. This field accepts URLs only. Keep it
            separate from first_frame and last_frame.
          anyOf:
            - type: string
              format: uri
              pattern: ^https://
            - type: array
              minItems: 1
              maxItems: 10
              items:
                type: string
                format: uri
                pattern: ^https://
        first_frame:
          description: >-
            Opening-frame image as one publicly accessible HTTPS URL or one PNG
            or JPEG file. Keep each file at or below 20 MiB (20 × 1024 × 1024
            bytes). Send the field once, using either a URL or a file. Pair with
            last_frame to set both boundaries. Keep frame inputs separate from
            input_reference.
          anyOf:
            - type: string
              format: uri
              pattern: ^https://
            - type: string
              format: binary
        last_frame:
          description: >-
            Closing-frame image as one publicly accessible HTTPS URL or one PNG
            or JPEG file. Keep each file at or below 20 MiB (20 × 1024 × 1024
            bytes). Send the field once, using either a URL or a file. To
            specify the closing image through this endpoint, send last_frame
            together with first_frame. Keep frame inputs separate from
            input_reference.
          anyOf:
            - type: string
              format: uri
              pattern: ^https://
            - type: string
              format: binary
      additionalProperties: false
      dependentRequired:
        last_frame:
          - first_frame
    Flux3VideoTask:
      type: object
      required:
        - id
        - object
        - model
        - status
        - progress
        - created_at
      properties:
        id:
          type: string
          description: Task ID. Use this value as task_id in retrieve and content requests.
          example: <task_id>
        task_id:
          type: string
          description: >-
            Compatibility alias for id. This field can be omitted from retrieve
            responses.
          example: <task_id>
        object:
          type: string
          const: video
          description: Object type for the asynchronous video task.
        model:
          type: string
          const: flux-3
          description: Model ID that the task uses.
        status:
          type: string
          enum:
            - queued
            - in_progress
            - completed
            - failed
          description: Task lifecycle status. Poll until the value is completed or failed.
        progress:
          type: integer
          minimum: 0
          maximum: 100
          description: Task progress as a coarse percentage.
        created_at:
          type: integer
          format: int64
          description: Task creation time as a Unix timestamp in seconds.
        completed_at:
          type: integer
          format: int64
          description: >-
            Task completion time as a Unix timestamp in seconds when the task
            provides one.
        expires_at:
          type: integer
          format: int64
          description: >-
            Result expiration time as a Unix timestamp in seconds when the task
            provides one.
        video_url:
          type: string
          format: uri
          description: Video delivery URL. This field appears on completed tasks.
          example: https://media.example.com/flux-3-result.mp4
        error:
          type: object
          description: Failure details. This field appears when the task fails.
          properties:
            message:
              type: string
              description: Human-readable failure description.
            code:
              type: string
              description: Failure code when the task provides one.
          additionalProperties: true
      additionalProperties: true
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Bearer authentication. Use your CometAPI API key.

````