OpenAI

GPT Image 2.6

gpt-image-2.6-flare/text-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-flare/text-to-image

Input

Showcases

View all showcases

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-flare/text-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
svg · 1K	~~$0.053~~ $0.0424	~~$0.071~~ $0.0568	~~$0.079~~ $0.0632	~~$0.117~~ $0.0936	~~$0.225~~ $0.180
svg · 2K	~~$0.072~~ $0.0576	~~$0.105~~ $0.084	~~$0.120~~ $0.096	~~$0.190~~ $0.152	~~$0.390~~ $0.312
svg · 4K	~~$0.105~~ $0.084	~~$0.163~~ $0.1304	~~$0.190~~ $0.152	~~$0.313~~ $0.2504	~~$0.666~~ $0.5328
gif · 1K · 2K · 4K	~~$0.070~~ $0.056	~~$0.124~~ $0.0992	~~$0.150~~ $0.120	~~$0.266~~ $0.2128	~~$0.598~~ $0.4784

Positioning Overview

gpt-image-2.6-flare/text-to-image is the speed-oriented, pure text-to-image route in OpenAI's gpt-image-2.6 image family, called through the unified HiAPI.ai interface. It turns a text prompt directly into a finished image, supports 1K to 4K resolution, multiple quality and complexity planning tiers, common aspect ratios, and can output PNG, JPEG, WebP, SVG, and GIF animations. It is suited to developers who need fast image generation at a low per-image cost, batch production at scale, or embedding image generation into automated pipelines.

Key Highlights

Low per-image cost, suited to batch generation — billed per image, with a simple pricing basis that makes it easy to estimate and spread the per-image cost across batch tasks.
A single call can produce vector and animated output — output_format supports svg and gif, so vector assets and frame-by-frame animations require no additional toolchain.
Quality and complexity can be adjusted separately — quality controls the rendering tier, while complexity independently controls the planning level, so dense text and complex layouts can be raised on demand.
Broad aspect ratio and resolution coverage — offers 16 ratios from 1:1 to 21:9 and 3:1, plus three output resolution tiers: 1K, 2K, and 4K.

Capabilities

Direct text-to-image generation: prompt is the only required input, up to 32000 characters, making it suitable for converting long structured descriptions directly into finished images without extra parameter assembly.

Multi-format output including SVG and GIF: output_format supports png, jpeg, webp, gif, and svg; choosing gif produces an animation, while choosing svg returns a vector file directly, expanding the types of deliverable assets.

Controllable GIF frame parameters: frame_size, frame_count (2-16 frames), and frame_duration_ms can be set to precisely control animation pacing and dimensions by pixel size and frame interval.

Transparent backgrounds and compressed output: background can be set to transparent and combined with png or webp output for transparent-background assets; with jpeg and webp, output_compression can be used to trade off file size against image quality.

Tiered quality, complexity, and resolution: quality provides five rendering tiers from low to max, complexity independently controls planning depth, and resolution can be 1K, 2K, or 4K, balancing speed and detail for the scenario.

Use Cases

Batch image generation for marketing and social media operations — enter campaign themes or copy descriptions and batch-generate images at ratios such as 16:9 and 1:1, ready for use on social platforms and in ad creative delivery.
Vector asset generation for design teams — use icon and illustration descriptions as input to output SVG files that can be delivered to design tools for further editing or used directly in front-end pages.
Lightweight animated asset generation for developers — generate GIFs via frame_count, frame_duration_ms, and frame_size for product demos, loading animations, or campaign page decoration.
Programmatic image generation in automated pipelines — call the interface from content systems or build scripts, assemble prompts with resolution and format parameters from templates, and batch-fill images for articles or products.

Limitations and Selection Advice

This route handles text-to-image only; when you need local edits based on an existing image or generation from reference images, use the image-to-image route in the same family instead. GIF output has an upper limit on the total amount of frame imagery; oversized frame dimensions or too many frames will be rejected by the submission side, and under GIF the dimensions are determined by frame_size, so aspect_ratio can only remain auto. Transparent backgrounds must be limited to png or webp, and when output_compression is used, output_format must be specified explicitly. If you care more about detail consistency across multi-turn edits, we recommend evaluating the Sunburst form first.

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-flare/text-to-image

routestringOptional

Current fixed value: default

inputobjectRequired

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

promptstringRequiredminLength 1maxLength 32000

Describe the image to generate, up to 32000 characters.

qualitystringOptionalDefault: "high"

Rendering quality level, options are low, medium, high, xhigh, max; defaults to high when not provided.

Options:lowmediumhighxhighmax

backgroundstringOptional

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

Options:autoopaquetransparent

complexitystringOptional

Planning level, independent of rendering quality: low suits simple images with a single subject, high suits dense text and complex layouts; defaults to high when not provided.

Options:lowmediumhigh

frame_sizestringOptionalpattern ^(auto|[0-9]+x[0-9]+)$

For GIF only: pixel width x height of each frame, e.g. 512x512; width and height together determine the GIF's aspect ratio. Both sides must be multiples of 16; ratio notation such as 1:1 is not accepted; defaults to 512x512 when not provided or set to auto. All frames are assembled into a single sheet; each side of the sheet must not exceed 3840, total pixels must not exceed 8,294,400, and aspect ratio must not exceed 3:1; requests exceeding these limits are rejected at submission and are not billed. 512x512 supports 2–16 frames, 768x768 supports up to 12 frames.

moderationstringOptional

Content moderation level, options are auto or low; defaults to low when not provided.

Options:autolow

resolutionstringOptionalDefault: "1K"

Output resolution level, options are 1K, 2K, 4K; defaults to 1K when not provided.

Options:1K2K4K

frame_countintegerOptionalDefault: 9min 2max 16

For GIF only: number of frames, an integer from 2–16; defaults to 9 when not provided. When frame size is 768x768, at most 12 frames.

aspect_ratiostringOptionalDefault: "auto"

Output aspect ratio; defaults to auto when not provided. GIF does not use this parameter: leave it unset or set to auto, and use frame_size to control each frame's size and 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, gif, svg; defaults to png when not provided. gif outputs an animated image, svg outputs a vector file; these two support text-to-image only. If output_compression is provided, jpeg or webp must also be provided; if any of frame_size, frame_count, or frame_duration_ms is provided, gif must be provided.

Options:pngjpegwebpgifsvg

frame_duration_msintegerOptionalDefault: 200min 20

For GIF only: display duration of each frame in milliseconds, minimum 20, rounded to the nearest 10 ms; defaults to 200 when not provided.

output_compressionintegerOptionalmin 0max 100

Compression level 0–100, used only for jpeg or webp; when this parameter is provided, 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-flare/text-to-image",
  "input": {
    "prompt": "…",
    "quality": "high",
    "resolution": "1K",
    "frame_count": 9,
    "aspect_ratio": "auto",
    "output_format": "png",
    "frame_duration_ms": 200
  }
}'

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-flare/text-to-image",
    input: {
      "prompt": "…",
      "quality": "high",
      "resolution": "1K",
      "frame_count": 9,
      "aspect_ratio": "auto",
      "output_format": "png",
      "frame_duration_ms": 200
    }
  }),
});
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-flare/text-to-image",
        "input": {
          "prompt": "…",
          "quality": "high",
          "resolution": "1K",
          "frame_count": 9,
          "aspect_ratio": "auto",
          "output_format": "png",
          "frame_duration_ms": 200
        }
    },
)
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"
    }
  }
}