# GPT Image 2.6 Pricing: Sunburst & Flare, $0.02–$0.21 per Image

> A 1024 GPT Image 2.6 image costs $0.025 at low, $0.043 at medium and $0.053 at high on OpenAI's token rates. Sunburst and Flare match, with no Batch discount.

- URL: https://blog.laozhang.ai/en/posts/gpt-image-2-6-pricing
- Published: 2026-11-05
- Updated: 2026-11-05
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: API Pricing & Plans
- Tags: GPT Image 2.6, OpenAI API, Image Generation, API Pricing

---
GPT Image 2.6 Sunburst and Flare cost exactly the same. OpenAI bills `gpt-image-2.6-sunburst` and `gpt-image-2.6-flare` per token, at $5 per 1M text input tokens, $8 per 1M image input tokens and $30 per 1M image output tokens, the same rates as GPT Image 2.5 ([OpenAI API pricing](https://developers.openai.com/api/docs/pricing), as of November 5, 2026). With the token counts measured the day after launch, a 1024×1024 image comes to about $0.025 at `low`, $0.043 at `medium`, $0.053 at `high`, $0.094 at `xhigh` and $0.21 at `max`. A landscape 1536×1024 image at `low` is the cheapest common case at about $0.020, and 2.6 has no half-price Batch rate yet.

The choice that moves your bill most is how you pay. Token billing, whether direct from OpenAI or through LaoZhang API's official forwarding at the same rates, wins only at `low`: $0.03 buys 1,000 output tokens, and a `low` 1024 image uses 824. From `medium` up, a flat $0.03 per call costs less. LaoZhang's `gpt-image-2.6-flare-vip` and `gpt-image-2.6-sunburst-vip` charge that for any size up to native 4K at qualities through `high`, and `gpt-image-2.6-web` charges it per GIF at 1024×1024. For token-billed requests, pass each response's `usage` object to the cost function further down; it reproduces the amounts actually billed.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

Three needs keep you on token billing regardless of the break-even: `xhigh` or `max` on 2.6, SVG output, and GIFs smaller than 816×816, such as 512×512. ChatGPT users don't pay per image at all, because Images 2.6 comes with every ChatGPT plan and the cost is the subscription.

## GPT Image 2.6 cost per image by quality and size

Cost per image is output tokens × $30 per million, plus prompt text that adds less than $0.001. The token counts below were measured by the LaoZhang API documentation team on November 5, 2026 with direct calls to OpenAI's API, one prompt and one run per cell. Flare's and Sunburst's counts matched or differed by a few dozen tokens at most (1,353 against 1,372 at 1536×1024 `high`), which is under $0.001 per image.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

| `quality` | Output tokens, 1024×1024 | Per 1024×1024 image | 1,000 images at 1024×1024 | Per 1536×1024 image | Per 3840×2160 image |
| --- | ---: | ---: | ---: | ---: | ---: |
| `low` | 824 | $0.025 | $24.72 | $0.020 | $0.047 |
| `medium` | 1,449 | $0.043 | $43.47 | $0.034 | not measured |
| `high` | 1,756 | $0.053 | $52.68 | $0.041 | $0.100 |
| `xhigh` | 3,122 | $0.094 | $93.66 | $0.074 | not measured |
| `max` | 7,024 | $0.211 | $210.72 | not measured | not measured |

These costs were recomputed on November 5, 2026 with cost = (text input tokens × $5 + image input tokens × $8 + output tokens × $30) ÷ 1,000,000, and the formula was checked against what the LaoZhang gateway actually billed for the same test requests. A `low` 1024 image with 15 prompt tokens and 824 output tokens works out to $0.02480 and was billed $0.02480; a 4-frame 512×512 GIF at `low` (36 and 1,172 tokens) works out to $0.03534 and was billed $0.03534. Landscape images used fewer tokens than square ones at every quality measured. Portrait 1024×1536 was not measured, so don't assume it matches landscape.

## Is Sunburst more expensive than Flare? Same price, different wait

No. At the same size and quality, `gpt-image-2.6-sunburst` and `gpt-image-2.6-flare` are billed at the same rates and use the same output tokens give or take a few dozen, under $0.001 per image, so a Sunburst image costs what a Flare image costs. The difference is time: in the November 5 tests, Flare returned a 1024×1024 image in 8 seconds at `low` and 12 at `high`, Sunburst in 34 and 59, and at `max` the gap was 39 seconds against 157. These are single runs, and queueing can shift them.

Which model suits which job, and whether to move from 2.5 at all, is covered in [GPT Image 2.6 vs 2.5: Same Price at High, 4× the Cost at Low](https://blog.laozhang.ai/en/posts/gpt-image-2-6-vs-2-5). The short version on price: from `high` up the two generations cost the same, while at `low` 2.6 uses 4.2× the tokens of 2.5 and at `medium` 3.3×.

## How edits, GIFs and SVGs change the GPT Image 2.6 bill

Each request type beyond plain text-to-image adds its own billed part. A GIF is one image sheet that holds every frame, so it's billed as the output tokens of that sheet rather than per frame. An SVG starts as an ordinary reference image, and then a text model writes the vector code at its own rate.

![Cost breakdown of a GPT Image 2.6 edit, a GIF billed as one sheet of frames, and an SVG made from a reference image plus a text model](https://blog.laozhang.ai/posts/en/gpt-image-2-6-pricing/img/edit-gif-svg-costs.webp)

| Request | What you're billed for | Example cost (Nov 5, 2026) |
| --- | --- | --- |
| Edit with one reference image (`/v1/images/edits`) | The output image as in the table above, plus the reference as image input, about 1,048 tokens per 1024 image at $8 per 1M | +$0.008 per reference image; a `low` 1024 edit ≈ $0.033 (billed $0.03301) |
| GIF (`output_format: "gif"`, `frame_count`) | Output tokens of one sheet holding all frames, growing with size, frame count and quality | 512×512 `low`, 4 frames: $0.035; 512×512 `medium`, 9 frames: $0.062 (2,073 tokens, 11–12 s) |
| SVG (`output_format: "svg"`, `svg.model`) | A reference image at your quality and size, then the text model that writes the SVG at that model's rate | `medium` reference $0.043, plus about $0.011–$0.015 per simple icon with `gpt-6.1-terra`, or $0.09–$0.16 with `gpt-5.5` |
| `complexity` set to `low`, `medium` or `high` | Nothing extra; token use stays the same at a given `quality` | $0 |
| Prompt text | Text input at $5 per 1M | under $0.001 |

GIFs have a size limit of their own. All frames share one sheet, so a small size with many frames fails with "No supported sheet fits…", and GIF output can't be streamed; 512×512 with 4–9 frames works. SVG is priced for icons and simple graphics. In the documentation team's tests, complex full scenes mostly ended in an OpenAI 502 error, so don't plan a budget around SVG illustrations.

## Token billing or $0.03 per call: the break-even is 1,000 tokens

Pay per token when your images stay at `low`, and pay $0.03 per call from `medium` up. At $30 per 1M output tokens, $0.03 buys exactly 1,000 tokens. A `low` 1024 image needs 824 and a `medium` one 1,449, so for 1,000 square images a month you'd pay $24.72 on tokens against $30 flat at `low`, and $52.68 against $30 at `high`. A 4K `high` image is about $0.10 on tokens against the same $0.03, and an edit with one reference image crosses the line even at `low`.

![Decision chart for paying for GPT Image 2.6 by token or at a flat $0.03 per call, by quality and output type](https://blog.laozhang.ai/posts/en/gpt-image-2-6-pricing/img/how-to-pay-picker.webp)

"VIP" and "web" are LaoZhang API's names for its two flat-priced 2.6 options, both called with a default-group key. Official forwarding sends your request to OpenAI's own models and bills OpenAI's token rates ([LaoZhang's GPT Image 2.6 announcement](https://docs.laozhang.ai/en/announcements/gpt-image-2-6-2026-11), as of November 5, 2026).

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

| Option | Model ID | Price | Quality and model choice | GIF | SVG | 4K |
| --- | --- | --- | --- | --- | --- | --- |
| OpenAI API | `gpt-image-2.6-flare`, `gpt-image-2.6-sunburst` | Token rates above | `low` to `max`, either model | Yes | Yes; writing model billed at its own rate | Native 3840×2160 |
| LaoZhang official forwarding (OpenAI Official or OpenAI Official Enterprise group) | Same IDs | Same token rates; Enterprise group +20% | `low` to `max`, either model | Yes | Yes; writing the SVG adds nothing with the default `gpt-6.1-terra` | Native 3840×2160 |
| LaoZhang 2.6 VIP | `gpt-image-2.6-flare-vip`, `gpt-image-2.6-sunburst-vip` | $0.03 per image at every size and quality it accepts, generate or edit | `low` to `high`, either model | No | No | Native 3840×2160, PNG only |
| LaoZhang 2.6 web | `gpt-image-2.6-web` | $0.03 per call, any size or frame count | Flare or Sunburst can't be chosen | Yes, 1024×1024 or larger, 2–64 frames, not from edits | No | Upscaled from about 2K |

On November 5, 2026, a default-group LaoZhang key ran the flat-priced options. `gpt-image-2.6-web` with `output_format: "gif"`, `size: "1024x1024"`, `frame_count: 6` and `frame_duration_ms: 150` returned a 1.4 MB GIF with exactly 6 frames in 41.4 seconds, while the same request at 512×512 came back as HTTP 400 with `"param":"size"`. On the VIP models, Sunburst at 1024×1024 returned PNGs at `low` (47.3 s) and `high` (65.8 s), Flare returned a 3840×2160 PNG at `high` in 32.3 s and a 1536×1024 PNG at `low` in 72.2 s, and `quality: "xhigh"` was refused with a 400 in 1.1 seconds. All four images are charged at the same $0.03 list price.

Two trade-offs come with the flat price. It's slower than Flare direct, which finishes a 1024 image in 8–12 seconds. And it stops at `high` on 2.6: if you need `xhigh` or `max` for $0.03, only the 2.5 VIP models (`gpt-image-2.5-flare-vip`, `gpt-image-2.5-sunburst-vip`) offer it, and that's the older model. On LaoZhang's official forwarding, a request that comes back non-200, including parameter errors and moderation blocks, isn't charged.

## What makes a GPT Image 2.6 bill bigger than you planned

Most budget surprises with 2.6 come from settings you didn't send, not from the rates themselves.

- Leaving out `quality` lets Flare pick a level from the prompt. In the November 5 tests, a detailed prompt used about 5,795 output tokens three times in a row, roughly $0.17 per 1024 image, and Sunburst without `quality` defaults to `high`.
- Batch isn't available. OpenAI's model pages list Batch as "Not supported" for both 2.6 models ([gpt-image-2.6-flare model page](https://developers.openai.com/api/docs/models/gpt-image-2.6-flare), as of November 5, 2026), and the Batch price table has no 2.6 rows, while 2.5 at `high` through Batch costs about $0.026 per 1024 image.
- Cached-input rates are listed for 2.6, but OpenAI's footnote applies them only to GPT Image 2 and 2.5 images made with the Responses API, so don't count on cache savings.
- LaoZhang's OpenAI Official Enterprise group adds 20% to every token, which puts a `high` 1024 image at $0.063.
- Every image you discard costs as much as one you keep. If you throw away one in three, budget 1.5× the per-image figure.

The `complexity` parameter isn't one of these. It changes how busy the scene is, and token use stays the same at a given `quality`.

## Why some pages show $4 or $8 per 1M tokens for GPT Image 2.6

Those numbers aren't OpenAI's prices for 2.6. A "starting price of $4 per 1M input tokens" is a reseller's own rate, and "$8 per 1M input and $8 per 1M output" is a shortened search snippet: the page behind it shows $8 for image input and $30 for image output, matching OpenAI. A rate such as $33 per 1M image output is also a reseller's own price, and pages saying the 2.6 price is unpublished were written before the November 4, 2026 launch. Headlines that call 2.6 "4× the cost" of 2.5 are true only at `low`. OpenAI's own rate card for both models is $5 text input, $8 image input and $30 image output per 1M tokens.

## Compute the cost of a GPT Image 2.6 response from its usage object

Every Image API response carries a `usage` object with `input_tokens_details.text_tokens`, `input_tokens_details.image_tokens` and `output_tokens` ([OpenAI image generation API reference](https://developers.openai.com/api/reference/resources/images/methods/generate)). This function turns them into dollars at OpenAI's rates and was run on November 5, 2026 against requests whose billed amounts were known.

```python
# Cost of one GPT Image 2.6 response from its `usage` object (OpenAI rates, Nov 2026).
RATES = {"text_in": 5.00, "image_in": 8.00, "image_out": 30.00}  # USD per 1M tokens

def image_cost_usd(usage: dict, enterprise_markup: float = 1.0) -> float:
    inp = usage.get("input_tokens_details") or {}
    text_in = inp.get("text_tokens", usage.get("input_tokens", 0))
    image_in = inp.get("image_tokens", 0)
    out = usage.get("output_tokens", 0)
    usd = (text_in * RATES["text_in"] + image_in * RATES["image_in"] + out * RATES["image_out"]) / 1_000_000
    return round(usd * enterprise_markup, 5)

if __name__ == "__main__":
    samples = {  # token counts from the Nov 5 test requests whose billed amounts are known
        "low 1024 generate (billed $0.02480)": {"input_tokens": 15, "input_tokens_details": {"text_tokens": 15, "image_tokens": 0}, "output_tokens": 824},
        "GIF 512 low 4 frames (billed $0.03534)": {"input_tokens": 36, "input_tokens_details": {"text_tokens": 36, "image_tokens": 0}, "output_tokens": 1172},
        "high 1024, Enterprise +20%": {"input_tokens": 15, "input_tokens_details": {"text_tokens": 15, "image_tokens": 0}, "output_tokens": 1756},
    }
    for name, u in samples.items():
        m = 1.2 if "Enterprise" in name else 1.0
        print(f"{name}: ${image_cost_usd(u, m):.5f}")
```

```text
low 1024 generate (billed $0.02480): $0.02480
GIF 512 low 4 frames (billed $0.03534): $0.03534
high 1024, Enterprise +20%: $0.06331
```

Log the result next to each request and you have a per-image cost history to set a monthly budget from. Use it only for token-billed requests; on the VIP and web models the price is a flat $0.03, and their `usage` numbers aren't the bill.

To set up the request itself (model IDs, first call in Python or curl, error fixes), see [GPT Image 2.6 API: Model IDs, Python and curl Code, Error Fixes](https://blog.laozhang.ai/en/posts/gpt-image-2-6-api).

## GPT Image 2.6 pricing: other questions

### How much does GPT Image 2.6 cost in ChatGPT?

There's no per-image price in ChatGPT. OpenAI's [Images 2.6 announcement](https://openai.com/index/introducing-images-2-6/) of November 4, 2026 puts it in ChatGPT and Codex on every subscription tier, so what you pay is your plan, and OpenAI publishes no per-plan image or GIF counts. For making GIFs inside ChatGPT, see [How to Make a GIF in ChatGPT (Images 2.6): Frames, Speed, Edits](https://blog.laozhang.ai/en/posts/how-to-make-a-gif-in-chatgpt).

### Is there a free GPT Image 2.6 API?

No. As of November 5, 2026, OpenAI's pricing page lists only paid token rates for `gpt-image-2.6-flare` and `gpt-image-2.6-sunburst`, with no free tier for either model.

### How much does GPT Image 2 cost?

GPT Image 2 has the same token rates as 2.6 on OpenAI's pricing page, and unlike 2.6 it still has a half-price Batch option, $15 per 1M image output tokens, as of November 5, 2026. Its per-image costs are in [GPT Image 2 API Pricing: Cost per Image, Batch, and $0.03 Calls](https://blog.laozhang.ai/en/posts/gpt-image-2-api-pricing), and 2.5's are in [GPT Image 2.5 Sunburst Pricing: Official Costs vs $0.03 per Call](https://blog.laozhang.ai/en/posts/gpt-image-2-5-api-pricing).

## Sources

External pages this guide links to, in the order they appear. Last updated 2026-11-05.

- [OpenAI API pricing](https://developers.openai.com/api/docs/pricing) (developers.openai.com)
- [gpt-image-2.6-flare model page](https://developers.openai.com/api/docs/models/gpt-image-2.6-flare) (developers.openai.com)
- [OpenAI image generation API reference](https://developers.openai.com/api/reference/resources/images/methods/generate) (developers.openai.com)
- [Images 2.6 announcement](https://openai.com/index/introducing-images-2-6/) (openai.com)