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

# 이미지 생성 작업 조회

> CometAPI GET /v1/images/generations/{task_id}를 사용해 비동기 OpenAI 호환 이미지 생성 작업을 폴링하고 최종 이미지 데이터를 가져옵니다.

`POST /v1/images/generations`와 `async: true`로 이미지를 생성한 뒤 이 엔드포인트를 사용하세요. 생성 요청은 `data.task_id`를 반환하며, 이 엔드포인트는 작업이 성공했을 때 작업 상태와 최종 이미지 데이터를 반환합니다.

## 이미지 작업 폴링

<Steps>
  <Step title="작업 생성">
    `POST /v1/images/generations`를 `async: true`와 함께 전송한 다음, `data.task_id`를 저장합니다.
  </Step>

  <Step title="작업 폴링">
    저장한 작업 ID로 이 엔드포인트를 호출하여 `data.status`가 `success` 또는 `failure`가 될 때까지 확인합니다.
  </Step>

  <Step title="이미지 데이터 읽기">
    `data.status`가 `success`이면 `data.data`의 첫 번째 항목을 읽습니다. 선택한 model에 따라 해당 항목에는 `b64_json`, `url`, 또는 `revised_prompt`가 포함될 수 있습니다.
  </Step>
</Steps>

## 상태 값

* `pending`: 작업이 대기열에 있거나 생성 중입니다.
* `success`: 작업이 완료되었고 `data.data`에 생성된 이미지 데이터가 포함되어 있습니다.
* `failure`: 작업이 실패했습니다. 반환되는 경우 `data.fail_reason`를 확인하세요.


## OpenAPI

````yaml api/openapi/image/openai/get-image-generation-task.openapi.json GET /v1/images/generations/{task_id}
openapi: 3.1.0
info:
  title: Image generation task API
  version: 1.0.0
  description: >-
    Retrieve an async image generation task created by `POST
    /v1/images/generations` with `async: true`.
servers:
  - url: https://api.cometapi.com
security:
  - bearerAuth: []
paths:
  /v1/images/generations/{task_id}:
    get:
      summary: Retrieve an image generation task
      description: >-
        Poll an async image generation task by task ID. Use the `task_id`
        returned by an async `POST /v1/images/generations` request.
      operationId: retrieve_image_generation_task
      parameters:
        - name: task_id
          in: path
          required: true
          description: Task ID returned in `data.task_id` by the async create request.
          schema:
            type: string
          example: <task_id>
      responses:
        '200':
          description: Current image generation task state.
          content:
            application/json:
              schema:
                type: object
                required:
                  - code
                  - data
                properties:
                  code:
                    type: string
                    description: >-
                      Request status code. Successful task lookups return
                      `success`.
                    example: success
                  message:
                    type: string
                    description: Optional status message.
                  data:
                    type: object
                    required:
                      - task_id
                      - status
                      - data
                    properties:
                      task_id:
                        type: string
                        description: Task ID for this image generation job.
                      status:
                        type: string
                        description: >-
                          Task state. Poll while the value is `pending`; read
                          `data[]` when the value is `success`.
                        enum:
                          - pending
                          - success
                          - failure
                      data:
                        type: array
                        description: >-
                          Generated image data. The array is empty until the
                          task succeeds.
                        items:
                          type: object
                          properties:
                            url:
                              type: string
                              description: >-
                                Temporary image URL when the selected model
                                supports URL output.
                            b64_json:
                              type: string
                              description: >-
                                Base64-encoded image payload for models that
                                return inline content.
                            revised_prompt:
                              type: string
                              description: Provider-rewritten prompt, when available.
                      fail_reason:
                        type: string
                        description: Failure reason when the task status is `failure`.
                example:
                  code: success
                  data:
                    task_id: <task_id>
                    status: success
                    data:
                      - b64_json: <base64-image-data>
              examples:
                pending:
                  summary: Pending task
                  value:
                    code: success
                    data:
                      task_id: <task_id>
                      status: pending
                      data: []
                success:
                  summary: Finished task
                  value:
                    code: success
                    data:
                      task_id: <task_id>
                      status: success
                      data:
                        - b64_json: <base64-image-data>
      x-codeSamples:
        - lang: Shell
          label: Poll until done
          source: |
            TASK_ID="<task_id>"

            while true; do
              RESPONSE=$(curl -s "https://api.cometapi.com/v1/images/generations/$TASK_ID" \
                -H "Authorization: Bearer $COMETAPI_KEY")
              STATUS=$(printf "%s" "$RESPONSE" | python3 -c "import json,sys; print(json.load(sys.stdin)['data']['status'])")
              echo "status: $STATUS"
              case "$STATUS" in success | failure) break;; esac
              sleep 3
            done

            printf "%s\n" "$RESPONSE"
        - 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:
                task = requests.get(
                    f"https://api.cometapi.com/v1/images/generations/{task_id}",
                    headers=headers,
                ).json()
                status = task["data"]["status"]
                print(status)
                if status in ("success", "failure"):
                    break
                time.sleep(3)

            if status == "success":
                print(task["data"]["data"][0].keys())
        - lang: JavaScript
          label: Poll until done
          source: >
            const taskId = "<task_id>";

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


            let task;

            while (true) {
              const response = await fetch(
                `https://api.cometapi.com/v1/images/generations/${taskId}`,
                { headers },
              );
              task = await response.json();
              const status = task.data.status;
              console.log(status);
              if (status === "success" || status === "failure") break;
              await new Promise((resolve) => setTimeout(resolve, 3000));
            }


            if (task.data.status === "success") {
              console.log(Object.keys(task.data.data[0]));
            }
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Bearer token authentication. Use your CometAPI key.

````