> ## 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.

# Kling Omni 비디오 가져오기

> CometAPI GET /kling/v1/videos/omni-video/{task_id}를 사용해 task_id로 Kling Omni 비디오 작업 상태와 결과를 가져옵니다.

Kling Omni 작업을 생성한 뒤 이 엔드포인트를 사용하세요. 작업이 성공하면 작업 상태와 최종 비디오 URL을 반환합니다.

## 먼저 이 필드를 확인하세요

* 쿼리 확인 응답을 위한 `code`, `message`, `request_id`
* `submitted`, `processing`, `succeed`, `failed` 같은 작업 상태를 나타내는 `data.task_status`
* 완료된 MP4 URL을 위한 `data.task_result.videos[0].url`
* 요청한 경우 워터마크가 포함된 MP4 URL을 위한 `data.task_result.videos[0].watermark_url`

## 폴링 패턴

<Steps>
  <Step title="먼저 작업 생성">
    [Create a Kling Omni video](./omni-video)로 시작하고 반환된 `task_id`를 저장합니다.
  </Step>

  <Step title="작업이 종료 상태가 될 때까지 폴링">
    `data.task_status`가 `succeed` 또는 `failed`에 도달할 때까지 계속 조회하세요.
  </Step>

  <Step title="반환된 MP4 URL 사용">
    작업이 성공하면 최종 비디오 URL을 즉시 다운로드하거나 복사하세요.
  </Step>
</Steps>


## OpenAPI

````yaml api/openapi/video/kling/get-omni-query.openapi.json GET /kling/v1/videos/omni-video/{task_id}
openapi: 3.1.0
info:
  title: Omni Query API
  version: 1.0.0
servers:
  - url: https://api.cometapi.com
security:
  - bearerAuth: []
paths:
  /kling/v1/videos/omni-video/{task_id}:
    get:
      summary: Omni Query
      operationId: omni_query
      parameters:
        - name: task_id
          in: path
          required: true
          description: Task id returned by the Omni Video endpoint.
          schema:
            type: string
      responses:
        '200':
          description: Current Kling task state.
          content:
            application/json:
              schema:
                type: object
                required:
                  - code
                  - message
                  - request_id
                  - data
                properties:
                  code:
                    type: integer
                    description: Kling response code. 0 indicates the query was accepted.
                  message:
                    type: string
                    description: Kling response message.
                  request_id:
                    type: string
                    description: Identifier for this query request.
                  data:
                    type: object
                    required:
                      - task_id
                      - task_status
                      - task_info
                      - created_at
                      - updated_at
                    properties:
                      task_id:
                        type: string
                        description: Kling task id.
                      task_status:
                        type: string
                        description: Current task state.
                        enum:
                          - submitted
                          - processing
                          - succeed
                          - failed
                      task_status_msg:
                        type: string
                        description: Failure or status detail when returned.
                      task_info:
                        type: object
                        description: Additional task metadata. The object can be empty.
                        additionalProperties: true
                      task_result:
                        type: object
                        description: >-
                          Result metadata. Present as an empty object while
                          processing and populated on success.
                        properties:
                          videos:
                            type: array
                            description: Generated videos.
                            items:
                              type: object
                              properties:
                                id:
                                  type: string
                                  description: Generated video id.
                                url:
                                  type: string
                                  description: Generated video URL.
                                duration:
                                  type: string
                                  description: Video duration in seconds.
                                watermark_url:
                                  type: string
                                  description: >-
                                    Watermarked video URL when watermark output
                                    is requested.
                        additionalProperties: true
                      created_at:
                        type: integer
                        description: Task creation timestamp in milliseconds.
                      updated_at:
                        type: integer
                        description: Last task update timestamp in milliseconds.
                      final_unit_deduction:
                        type: string
                        description: >-
                          Final unit deduction returned after a successful task,
                          when available.
              examples:
                Processing:
                  summary: Task still rendering
                  value:
                    code: 0
                    message: SUCCEED
                    request_id: <request_id>
                    data:
                      task_id: <task_id>
                      task_status: processing
                      task_info: {}
                      task_result: {}
                      created_at: 1781080355827
                      updated_at: 1781080362336
                Succeed:
                  summary: Finished task with video result
                  value:
                    code: 0
                    message: SUCCEED
                    data:
                      task_id: <task_id>
                      task_status: succeed
                      task_info: {}
                      created_at: 1781074110938
                      updated_at: 1781074171088
                      task_result:
                        videos:
                          - id: <video_id>
                            url: https://your-video-host/generated.mp4
                            duration: '5.1'
                            watermark_url: https://your-video-host/generated-watermarked.mp4
                    request_id: <request_id>
      x-codeSamples:
        - lang: Shell
          label: Default
          source: >
            TASK_ID="<task_id>"


            curl "https://api.cometapi.com/kling/v1/videos/omni-video/$TASK_ID"
            \
              -H "Authorization: Bearer $COMETAPI_KEY"
        - lang: Shell
          label: Poll until done
          source: |
            TASK_ID="<task_id>"

            while true; do
              STATUS=$(curl -s "https://api.cometapi.com/kling/v1/videos/omni-video/$TASK_ID" \
                -H "Authorization: Bearer $COMETAPI_KEY" | python3 -c "import json,sys; print(json.load(sys.stdin)['data']['task_status'])")
              echo "status: $STATUS"
              case "$STATUS" in succeed | failed) break;; esac
              sleep 30
            done
        - lang: Python
          label: Default
          source: |
            import os
            import requests

            task_id = "<task_id>"

            response = requests.get(
                f"https://api.cometapi.com/kling/v1/videos/omni-video/{task_id}",
                headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
            )

            print(response.json()["data"]["task_status"])
        - lang: Python
          label: Poll until done
          source: |
            import os
            import time
            import requests

            task_id = "<task_id>"
            headers = {"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]}

            while True:
                data = requests.get(
                    f"https://api.cometapi.com/kling/v1/videos/omni-video/{task_id}", headers=headers
                ).json()["data"]
                print(data["task_status"])
                if data["task_status"] in ("succeed", "failed"):
                    break
                time.sleep(30)

            if data["task_status"] == "succeed":
                print(data["task_result"])
        - lang: JavaScript
          label: Default
          source: >
            const taskId = "<task_id>";


            const response = await
            fetch(`https://api.cometapi.com/kling/v1/videos/omni-video/${taskId}`,
            {
                headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
            });


            const result = await response.json();

            console.log(result.data.task_status);
        - lang: JavaScript
          label: Poll until done
          source: >
            const taskId = "<task_id>";

            const headers = { Authorization: `Bearer
            ${process.env.COMETAPI_KEY}` };


            let data;

            while (true) {
                data = (await (await fetch(`https://api.cometapi.com/kling/v1/videos/omni-video/${taskId}`, { headers })).json()).data;
                console.log(data.task_status);
                if (data.task_status === "succeed" || data.task_status === "failed") break;
                await new Promise((resolve) => setTimeout(resolve, 30000));
            }


            if (data.task_status === "succeed") console.log(data.task_result);
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Bearer token authentication. Use your CometAPI key.

````