> ## 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 中使用 POST /v1/images/edits，透過 multipart 上傳、遮罩、GPT 圖像模型與編碼圖片輸出控制來編輯圖片。

使用此路由可在 CometAPI 上以相容 OpenAI 的 multipart 上傳方式編輯現有圖片。

## 在以下情況使用此路由

* 你已經有來源圖片，且想要進行由 Prompt 驅動的編輯
* 你可能需要使用遮罩來進行針對性的修改
* 你可以處理 multipart 檔案上傳，而不是單純的 JSON 請求

## 安全的第一個請求

* 先從一個 PNG 或 JPG 檔案開始
* 在基本編輯流程可正常運作前，先不要使用遮罩
* 在此路由上進行 GPT 圖片編輯請求時，使用 `model: "gpt-image-2"`
* 使用一個簡短指令，只要求一項可見的變更
* 從 `data[0].b64_json` 讀取編輯後的結果
* 當你想要 JPEG 負載時，設定 `output_format: "jpeg"`
* 預期延遲會比一般圖片生成更長

## 模型行為

* 此路由上的 GPT 圖片編輯模型會回傳內嵌的 base64 圖片資料
* `output_format` 會控制 `b64_json` 內部的編碼圖片類型
* `response_format` 只有在模型支援 URL 輸出時才有作用
* `qwen-image-edit` 會在相同的 CometAPI 路由後方遵循供應商特定的編輯行為


## OpenAPI

````yaml api/openapi/image/openai/post-image-editing.openapi.json POST /v1/images/edits
openapi: 3.1.0
info:
  title: Image Editing API
  version: 1.0.0
  description: >-
    Edit existing images through the OpenAI-compatible CometAPI image edits
    route. GPT image edit models return inline base64 payloads in
    `data[].b64_json`, and `output_format` controls the encoded image type.
servers:
  - url: https://api.cometapi.com
security:
  - bearerAuth: []
paths:
  /v1/images/edits:
    post:
      summary: Edit images
      description: >-
        Upload one or more source images, optionally include a mask, and request
        an edited result with a text instruction.
      operationId: image_editing
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              required:
                - image
                - prompt
              properties:
                image:
                  type: string
                  format: binary
                  description: >-
                    Source image file. Start with one PNG or JPG input for the
                    simplest flow.
                prompt:
                  type: string
                  description: Edit instruction describing the change you want.
                  example: Add a small red ribbon to the paper boat.
                model:
                  type: string
                  description: >-
                    The image editing model to use. Choose a supported model
                    from the [Models page](/overview/models).
                  default: gpt-image-2
                mask:
                  type: string
                  format: binary
                  description: >-
                    Optional PNG mask. Transparent areas mark the regions to
                    edit. The mask dimensions must match the source image
                    exactly.
                'n':
                  type: string
                  description: Number of edited images to return.
                  default: '1'
                quality:
                  type: string
                  enum:
                    - high
                    - medium
                    - low
                  description: Quality setting for models that support it.
                response_format:
                  type: string
                  enum:
                    - url
                    - b64_json
                  description: >-
                    Requested response container when supported by the selected
                    model. GPT image edit models return `data[].b64_json`; use
                    `output_format` to choose the encoded image type.
                output_format:
                  type: string
                  description: >-
                    Encoded image type for GPT image edit results returned in
                    `data[].b64_json`. For example, use `jpeg` for a JPEG
                    payload.
                  example: jpeg
                size:
                  type: string
                  description: Requested output size when supported by the selected model.
              default:
                model: gpt-image-2
                prompt: Add a small red ribbon to the paper boat.
                output_format: jpeg
      responses:
        '200':
          description: Edited image result.
          content:
            application/json:
              schema:
                type: object
                required:
                  - created
                  - data
                  - usage
                properties:
                  created:
                    type: integer
                  usage:
                    type: object
                    properties:
                      prompt_tokens:
                        type: integer
                      completion_tokens:
                        type: integer
                      total_tokens:
                        type: integer
                      prompt_tokens_details:
                        type: object
                        properties:
                          cached_tokens_details:
                            type: object
                            properties: {}
                      completion_tokens_details:
                        type: object
                        properties: {}
                      input_tokens:
                        type: integer
                      output_tokens:
                        type: integer
                      input_tokens_details:
                        type: object
                        properties:
                          image_tokens:
                            type: integer
                          text_tokens:
                            type: integer
                          cached_tokens_details:
                            type: object
                            properties: {}
                      claude_cache_creation_5_m_tokens:
                        type: integer
                      claude_cache_creation_1_h_tokens:
                        type: integer
                  data:
                    type: array
                    items:
                      type: object
                      properties:
                        b64_json:
                          type: string
                          description: >-
                            Base64-encoded image payload. Decode this value to
                            get the edited image bytes.
                        url:
                          type: string
                          description: >-
                            Temporary image URL when the selected model supports
                            URL output.
                        revised_prompt:
                          type: string
                          description: Provider-rewritten prompt, when available.
                  background:
                    type: string
                    description: Background mode returned by models that expose it.
                  output_format:
                    type: string
                    description: Encoded image type returned by GPT image models.
                  quality:
                    type: string
                    description: Quality level returned by models that expose it.
                  size:
                    type: string
                    description: Output size returned by models that expose it.
                example:
                  created: 1776836647
                  usage:
                    prompt_tokens: 0
                    completion_tokens: 0
                    total_tokens: 981
                    prompt_tokens_details:
                      cached_tokens_details: {}
                    completion_tokens_details: {}
                    input_tokens: 785
                    output_tokens: 196
                    input_tokens_details:
                      image_tokens: 768
                      text_tokens: 17
                      cached_tokens_details: {}
                    claude_cache_creation_5_m_tokens: 0
                    claude_cache_creation_1_h_tokens: 0
                  data:
                    - b64_json: <base64-image-data>
              example:
                created: 1781075000
                background: opaque
                output_format: png
                quality: low
                size: 1024x1024
                usage:
                  input_tokens: 784
                  input_tokens_details:
                    image_tokens: 768
                    text_tokens: 16
                  output_tokens: 196
                  output_tokens_details:
                    image_tokens: 196
                    text_tokens: 0
                  total_tokens: 980
                data:
                  - b64_json: iVBORw0KGgoAAAANSUhEUgAA...
      x-codeSamples:
        - lang: Shell
          label: Default
          source: |
            curl https://api.cometapi.com/v1/images/edits \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              -F image=@cat.jpg \
              -F prompt="Add a small red bow tie on the cat" \
              -F model=gpt-image-2 \
              -F quality=low
        - lang: Shell
          label: With mask
          source: >
            # The mask is a PNG whose transparent areas mark the regions to
            edit.

            # Its dimensions must match the source image exactly.

            curl https://api.cometapi.com/v1/images/edits \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              -F image=@cat.jpg \
              -F mask=@mask.png \
              -F prompt="Replace the masked area with a red bow tie" \
              -F model=gpt-image-2 \
              -F quality=low
        - lang: Python
          label: Default
          source: |
            import base64
            import os
            from openai import OpenAI

            client = OpenAI(
                base_url="https://api.cometapi.com/v1",
                api_key=os.environ["COMETAPI_KEY"],
            )

            with open("cat.jpg", "rb") as image_file:
                result = client.images.edit(
                    model="gpt-image-2",
                    image=image_file,
                    prompt="Add a small red bow tie on the cat",
                    quality="low",
                )

            image_bytes = base64.b64decode(result.data[0].b64_json)
            with open("edited.png", "wb") as f:
                f.write(image_bytes)
        - lang: Python
          label: With mask
          source: >
            import base64

            import os

            from openai import OpenAI


            client = OpenAI(
                base_url="https://api.cometapi.com/v1",
                api_key=os.environ["COMETAPI_KEY"],
            )


            # The mask is a PNG whose transparent areas mark the regions to
            edit.

            # Its dimensions must match the source image exactly.

            with open("cat.jpg", "rb") as image_file, open("mask.png", "rb") as
            mask_file:
                result = client.images.edit(
                    model="gpt-image-2",
                    image=image_file,
                    mask=mask_file,
                    prompt="Replace the masked area with a red bow tie",
                    quality="low",
                )

            image_bytes = base64.b64decode(result.data[0].b64_json)

            with open("edited.png", "wb") as f:
                f.write(image_bytes)
        - lang: JavaScript
          label: Default
          source: >
            import fs from "node:fs";

            import OpenAI, { toFile } from "openai";


            const client = new OpenAI({
                baseURL: "https://api.cometapi.com/v1",
                apiKey: process.env.COMETAPI_KEY,
            });


            const result = await client.images.edit({
                model: "gpt-image-2",
                image: await toFile(fs.createReadStream("cat.jpg"), "cat.jpg", { type: "image/jpeg" }),
                prompt: "Add a small red bow tie on the cat",
                quality: "low",
            });


            fs.writeFileSync("edited.png", Buffer.from(result.data[0].b64_json,
            "base64"));
        - lang: JavaScript
          label: With mask
          source: >
            import fs from "node:fs";

            import OpenAI, { toFile } from "openai";


            const client = new OpenAI({
                baseURL: "https://api.cometapi.com/v1",
                apiKey: process.env.COMETAPI_KEY,
            });


            // The mask is a PNG whose transparent areas mark the regions to
            edit.

            // Its dimensions must match the source image exactly.

            const result = await client.images.edit({
                model: "gpt-image-2",
                image: await toFile(fs.createReadStream("cat.jpg"), "cat.jpg", { type: "image/jpeg" }),
                mask: await toFile(fs.createReadStream("mask.png"), "mask.png", { type: "image/png" }),
                prompt: "Replace the masked area with a red bow tie",
                quality: "low",
            });


            fs.writeFileSync("edited.png", Buffer.from(result.data[0].b64_json,
            "base64"));
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Bearer token authentication. Use your CometAPI key.

````