OpenAI

GPT Image 2.6

gpt-image-2.6-sunburst/image-to-image

OpenAI's two-tier image generation and editing models: Flare focuses on speed, Sunburst on precision, with direct GIF and SVG output and partial image edits

gpt-image-2.6-flare/image-to-image gpt-image-2.6-flare/text-to-image gpt-image-2.6-sunburst/image-to-image gpt-image-2.6-sunburst/text-to-image

Try gpt-image-2.6-sunburst/image-to-image

Input

Output

image

Fill in the parameters and run — results show up here.

Pricing

GPT Image 2.6 Launch: Limited-Time 20% Off 20% OFF · Ends 2026-11-13 View deal

gpt-image-2.6-sunburst/image-to-image per image

Specifications	low	medium	high	xhigh	max
1K	~~$0.023~~ $0.0184	~~$0.041~~ $0.0328	~~$0.049~~ $0.0392	~~$0.087~~ $0.0696	~~$0.195~~ $0.156
2K	~~$0.042~~ $0.0336	~~$0.075~~ $0.060	~~$0.090~~ $0.072	~~$0.160~~ $0.128	~~$0.360~~ $0.288
4K	~~$0.075~~ $0.060	~~$0.133~~ $0.1064	~~$0.160~~ $0.128	~~$0.283~~ $0.2264	~~$0.636~~ $0.5088

Positioning Overview

gpt-image-2.6-sunburst/image-to-image is a model for image-to-image editing: it takes one or more source images plus an editing description and outputs the modified image. Its focus is keeping details consistent across multiple editing rounds — when the same character, product, or layout is adjusted repeatedly, the visual details stay more stable, making it suited for visual asset production that requires continuous iteration. Developers can call it through the unified HiAPI.ai interface, billed per image.

Core Highlights

Consistent details across multiple editing rounds — at the medium or high quality tier, it keeps character, product, and layout details consistent across editing rounds, making it suitable for repeated fine-tuning.
Annotation-based local editing — a transparent overlay with circles or annotations can be submitted as modification hints; the annotations themselves are not retained in the output.
Multi-source image composition and wide-format output — supports passing up to 16 source images at once, and offers aspect ratios from 3:1 to 1:3 and resolution tiers from 1K to 4K.

Capabilities

Image editing based on source images: takes 1 to 16 jpeg, png, or webp source images as input and redraws or modifies the image according to an editing description of up to 32,000 characters; the output type is independent of the source images and can be converted directly into the required delivery format.

Two localization methods: masks and markup: mask_url accepts an RGBA PNG of the same dimensions as the first source image, marking the edit area with transparent pixels; markup_url uses a transparent overlay as a circle-based hint. The two are mutually exclusive.

Layered control of quality and planning: quality controls the rendering tier (low to max), while complexity separately controls planning depth — dense text and complex layouts can be handled with a higher planning level without simultaneously raising rendering cost.

Output format and background handling: png, jpeg, and webp output are available; jpeg and webp support a compression level from 0 to 100; transparent backgrounds are limited to png or webp, suitable for assets that need to be overlaid directly onto pages or design files.

Selectable resolution and aspect ratio: output resolution can be 1K, 2K, or 4K, and the aspect ratio can automatically follow the source image or be specified from 16 presets ranging from 1:1 to 21:9, so a single generation can match the target placement.

Use Cases

Design teams: iterating character and product series images — repeatedly edit existing character images with modification descriptions to produce series visual assets with stable details, unifying brand materials and product images.
Marketing teams: batch adaptation of campaign assets — use existing key visuals as source images and output assets in multiple placements with different aspect ratios and resolutions, ready for ad delivery and social media publishing.
Developers: annotation-driven local modifications — upload an overlay with circles to specify the areas to change and produce locally corrected images, integrating into content production pipelines to reduce manual rework.
Front-end and page building: transparent cutout generation — use reference images as source images to output transparent-background png or webp files for direct use in page elements and component assets.

Limitations and Selection Advice

The limitations mainly concern quality tiers and input forms: the advantage of consistent details across rounds holds only at medium or high quality and is not guaranteed at low quality tiers; masks and markup cannot be used at the same time, and a mask only marks the edit area — the entire image may still be redrawn; transparent backgrounds require png or webp output, and compression parameters apply only to jpeg and webp. If the task is primarily direct text-to-image generation without source-image constraints, the text-to-image route in the same family should be used instead.

Frequently asked questions

View all FAQs →

How is billing calculated? Will I be charged if a request is rejected?

Billed per image; the unit price is determined by quality tier and resolution, as shown in the price table on this page; Flare and Sunburst are priced the same. For image-to-image, each reference image adds $0.012. GIFs are priced separately by quality tier, regardless of resolution. Requests with invalid parameters or GIF dimensions exceeding the limit are rejected at the submission stage, and the pre-authorized charge is fully refunded with no fee deducted.
Can I modify only part of an image?

Yes, use the image-to-image route, with one of two options. The first is mask_url: pass an RGBA PNG of the same dimensions as the first source image, where fully transparent pixels are the areas to be modified. The second is markup_url: pass a transparent PNG annotation image that marks the locations to change with circles or similar markings; the annotations themselves will not appear in the result. The two cannot be passed at the same time. Even with a mask, the model may still make slight redraws across the entire image.
What is the difference between Flare and Sunburst, and which one should I choose?

The two have exactly the same parameters, usage, and pricing; the difference lies in their focus. According to OpenAI's introduction, Flare generates images faster, making it suitable for rapid iteration and batch image generation, and is the recommended default choice; Sunburst emphasizes detail more, and during multi-round editing at the medium quality level and above, it keeps character, product, or layout details more consistent. Generally, start with Flare; when the same image needs repeated revisions and detail stability is required, switch to Sunburst and set quality to medium or higher.
Can it generate GIF animations or SVG vector graphics directly?

Yes. On the text-to-image route, just set output_format to gif or svg; the image-to-image route only supports png, jpeg, and webp. GIF is controlled by three parameters: set frame_size to the pixel size of each frame (default 512x512; the width and height also determine the GIF's aspect ratio), set frame_count to the number of frames (2–16, default 9), and set frame_duration_ms to the duration of each frame (default 200 milliseconds). When generating a GIF, either omit aspect_ratio or pass auto.

Create a generation task

POST https://api.hiapi.ai/v1/tasks

Headers

AuthorizationstringRequired

Account API key. Required on every request. Example: Bearer YOUR_HIAPI_API_KEY. Get your API key

Content-TypestringOptional

The request body is always parsed as JSON; when sent, only application/json (optionally with charset) is accepted — any other value returns 415. Example: application/json.

Idempotency-KeystringOptional

Idempotency key, up to 255 bytes. Retries with the same key from the same account create the task only once; replays return the original taskId.

Idempotency key

On network timeouts or client retries, the same key creates the task only once — no double charges (scope: the API key's account). Use a business-unique identifier as the key (e.g. "order-42"); replays return the original taskId, and keys expire 24 hours after the first request. See the Unified Async API overview for the full scenario matrix.

Body

modelstringRequired

Current fixed value: gpt-image-2.6-sunburst/image-to-image

routestringOptional

Current fixed value: default

inputobjectRequired

Business parameters for gpt-image-2.6-sunburst/image-to-image and route default — see the parameter table below.

promptstringRequiredminLength 1maxLength 32000

Describe the edits to make to the source image, or the picture to generate based on the source image; up to 32000 characters.

qualitystringOptionalDefault: "high"

Render quality tier; options are low, medium, high, xhigh, max; defaults to high when omitted.

Options:lowmediumhighxhighmax

mask_urlstringOptional

Mask image URL: an RGBA PNG with the same dimensions as the first source image, where fully transparent pixels mark the regions to edit; the entire image may still be slightly redrawn. Cannot be sent together with markup_url.

backgroundstringOptional

Background mode; options are auto, opaque, transparent; transparent requires output in png or webp.

Options:autoopaquetransparent

complexitystringOptional

Planning tier, independent of render quality: low suits localized, single-point edits, high suits dense text and complex layouts; defaults to high when omitted.

Options:lowmediumhigh

image_urlsarrayRequiredminItems 1maxItems 16

Array of source image URLs, 1–16 publicly accessible http(s) images, supporting jpeg, png, webp.

Array [ string ]

markup_urlstringOptional

Markup image URL: a transparent PNG overlay that uses circles and other marks to indicate the locations to edit; the markup itself does not appear in the result. Cannot be sent together with mask_url.

moderationstringOptional

Content moderation level; options are auto or low; defaults to low when omitted.

Options:autolow

resolutionstringOptionalDefault: "1K"

Output resolution tier; options are 1K, 2K, 4K; defaults to 1K when omitted.

Options:1K2K4K

aspect_ratiostringOptionalDefault: "auto"

Output aspect ratio; defaults to auto when omitted, which follows the source image's ratio.

Options:auto1:13:22:34:33:45:44:5

Show all (8)

16:99:162:11:221:99:213:11:3

output_formatstringOptionalDefault: "png"

Output format; options are png, jpeg, webp; defaults to png when omitted. If output_compression is sent, jpeg or webp must also be sent.

Options:pngjpegwebp

output_compressionintegerOptionalmin 0max 100

Compression level 0–100, only used for jpeg or webp; when sending this parameter, output_format must also be set to jpeg or webp.

callbackobjectOptional

Terminal-state notification config. When omitted, no callback is delivered — poll the task yourself. See the callback note below.

Callbacks (Webhook)

Provide callback.url when creating a task and HiAPI POSTs to your service once the task reaches a terminal state — no polling needed. The callback payload mirrors the task detail structure; signature verification, delivery retries and idempotency are documented on the Unified Async API overview page.

urlstringRequired

Required when callback is present. A POST is sent to this URL once the task reaches a terminal state; must be a valid http(s) URL.

whenstringOptionalDefault: "final"

Only final is supported today — notified on both success and fail.

Options:final

storagestringOptionalDefault: "temp"

Artifact storage tier: temp (default, retained about 7 days) or persistent (long-term, billed by size). Insufficient balance or exceeding the storage cap silently downgrades to temp; the effective tier is shown in the task detail response.

Options:temppersistent

Request examples

# Submit an async task; returns a taskId immediately (no waiting for generation)
curl -X POST "https://api.hiapi.ai/v1/tasks" \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-image-2.6-sunburst/image-to-image",
  "input": {
    "prompt": "…",
    "quality": "high",
    "image_urls": "…",
    "resolution": "1K",
    "aspect_ratio": "auto",
    "output_format": "png"
  }
}'

const res = await fetch("https://api.hiapi.ai/v1/tasks", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.HIAPI_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-image-2.6-sunburst/image-to-image",
    input: {
      "prompt": "…",
      "quality": "high",
      "image_urls": "…",
      "resolution": "1K",
      "aspect_ratio": "auto",
      "output_format": "png"
    }
  }),
});
const task = await res.json();
// { code: 200, message: "success", data: { taskId } }

import os, requests

res = requests.post(
    "https://api.hiapi.ai/v1/tasks",
    headers={"Authorization": f"Bearer {os.environ['HIAPI_API_KEY']}"},
    json={
        "model": "gpt-image-2.6-sunburst/image-to-image",
        "input": {
          "prompt": "…",
          "quality": "high",
          "image_urls": "…",
          "resolution": "1K",
          "aspect_ratio": "auto",
          "output_format": "png"
        }
    },
)
print(res.json())  # { code, message, data: { taskId } }

200 OK

{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "tk-hiapi-01HZTQ8BX2N3GM3YFK4Z9D7VQR"
  }
}

400 Bad Request

{
  "code": 400,
  "message": "invalid request",
  "data": null,
  "error_code": "INVALID_REQUEST"
}

Get task detail

GET https://api.hiapi.ai/v1/tasks/:id

Response fields

taskIdstringRequired

Task ID, always prefixed with tk-hiapi-.

modelstringRequired

Resolved full model name. Tasks submitted with the route parameter return base@route (e.g. gpt-image-2/text-to-image@ext); otherwise identical to the name passed at creation.

routestringOptional

Present only when the task was submitted with an explicit route parameter; echoes the submitted value.

statusstringRequired

Task status.

Status values

queued Queued, not started yet. handling Being processed. archiving Processing finished, artifacts being prepared. success Terminal: completed, artifacts available (output returned). fail Terminal: failed (error returned). After submission, check status: success and fail are terminal, everything else is non-terminal. Poll every 1–3 seconds until terminal. On success, download artifacts from output[].url and transfer them before expireAt; pass storage: "persistent" at creation time when long-term retention is needed.

creatednumberRequired

Task creation time (Unix seconds).

completednumberRequired

Unix seconds when the task reached a terminal state; fixed to 0 while not terminal.

outputarrayOptional

Present only when status == success. Artifact list — always an array; a single task may return multiple types at once (e.g. video + first_frame).

Array [ object ]

Array items

urlstringRequired

Artifact URL, directly downloadable.

typestringRequired

Current possible values: video, image, audio, first_frame, last_frame, thumbnail; more may be added later.

expireAtnumberRequired

Unix seconds until which the artifact remains accessible; download or transfer before it expires.

errorobjectOptional

Present only when status == fail.

codestringRequired

Business error code.

messagestringRequired

Error description.

Response examples

Success

{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "tk-hiapi-01HZTQ8BX2N3GM3YFK4Z9D7VQR",
    "model": "happyhorse-1-0",
    "status": "success",
    "created": 1777282033,
    "completed": 1777282099,
    "output": [
      {
        "url": "https://cdn.hiapi.ai/tasks/.../video.mp4",
        "type": "video",
        "expireAt": 1777886899
      }
    ]
  }
}

Processing (non-terminal)

{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "tk-hiapi-...",
    "model": "happyhorse-1-0",
    "status": "archiving",
    "created": 1777282033,
    "completed": 0
  }
}

Failed

{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "tk-hiapi-...",
    "model": "happyhorse-1-0",
    "status": "fail",
    "created": 1777282033,
    "completed": 1777282099,
    "error": {
      "code": "TASK_FAILED",
      "message": "task failed"
    }
  }
}