GPT Image 2.6 Pricing: Same Output Rate, Up to 4.2x Per Image

GPT Image 2.6 Pricing: Same Output Rate, Up to 4.2x Per Image

OpenAI shipped GPT Image 2.6 on November 4, according to its API changelog. There are two models, gpt-image-2.6-sunburst and gpt-image-2.6-flare, and they add three things developers have wanted for a while: adjustable complexity, SVG output and animated GIFs.

The $30 per 1M image output rate didn't move. That's the number on the model pages.

But the per-image cost did move. At low quality, a 1024x1024 image now costs about four times what it did on 2.5.

That's not a forum rumor. It's hard-coded in OpenAI's own cost calculator. Here's what shipped, what it really costs, and where it'll trip you up.

We read the changelog, both model pages and the image generation guide, and reran the guide's cost formula ourselves. We haven't generated 2.6 images on our own prompts yet, so nothing below is a quality judgment.

What GPT Image 2.6 Actually Ships

Both models live on the same two endpoints, v1/images/generations and v1/images/edits. The model pages list Chat Completions, Responses, Realtime and Batch as not supported.

OpenAI describes Sunburst as image generation and editing for detailed visual work. Flare gets the same line, ending for fast iteration instead.

That, plus a mention of interactive workflows on Flare's page, is the entire documented difference. There's no published speed number, no separate price and no different feature list. So the Sunburst vs Flare choice comes down to testing both on your own prompts.

Pricing is identical for both, per 1M tokens:

Rate limits vary by usage tier and account. OpenAI doesn't publish numbers, so check your own dashboard before you plan a batch job.

GPT Image 2.6 Cost Per Image: Up to a 4.2x Jump

Here's the part that isn't on the model pages. The image generation guide includes a cost calculator, and its code takes the 2.5 token counts and multiplies them for 2.6.

At low quality, the multiplier is 4.2. At medium, it's 3.3. At high, xhigh and max, it's 1, so nothing changes.

We ran the calculator's formula ourselves. It reproduces OpenAI's published gpt-image-2 prices ($0.006, $0.053 and $0.211), and its 2.6 low result for 1024x1024 (823 tokens, $0.02469) matches our run. Here's what that means per image, counting output tokens only:

Run the math on a real workload. Say you generate 100,000 low-quality square thumbnails a month. That's about $588 on 2.5 and about $2,469 on 2.6, before input tokens.

Quick sanity check, though. Medium on 2.6 ($0.043) is still cheaper than medium on the older gpt-image-2 ($0.053). If you're coming straight from gpt-image-2 at medium, 2.6 actually costs less (though the tiers aren't one-to-one across models).

Who gets hit? Anyone who picked low or medium specifically because it was cheap. If you already run at high or above, your bill stays the same.

There's a second effect here that's easy to miss. On 2.5, dropping from high to low cut output tokens by about 9x (1,756 down to 196). On 2.6, the same drop saves barely 2x (1,756 down to 823).

So the old trick of drafting at low and finishing at high doesn't save much anymore. If low quality on 2.6 doesn't look clearly better than low on 2.5, you're paying more for drafts and getting little back.

Complexity, SVG and GIF Output: The Technical Breakdown

The complexity parameter

There's a new request field, complexity, with values low, medium and high. It's separate from quality, which on 2.5 and 2.6 runs low, medium, high, xhigh and max.

If you leave it out, both models use high. Changing it costs nothing extra. OpenAI warns that higher complexity can increase latency and introduce unwanted changes, so a simple icon request may come out better at low.

GPT Image 2.6 SVG output

Set output_format: svg on the generations endpoint. The rules are strict:

• n must be 1.
• No streaming, partial images, output_compression or prompt_rewriter.
• The edits endpoint can't output SVG, and you can't send an SVG in as an edit input.
• The file is static, with no scripts, external resources, or embedded raster images.

Under the hood, the API first makes a reference image, and quality controls that step. Then an authoring model writes the SVG.

You pay the image model's rate plus the authoring model's rate, and OpenAI doesn't name that model or its price. So you can't predict an SVG's exact cost ahead of time.

GPT Image 2.6 GIF Output (Animated)

Set output_format: gif, again on generations only. You control:

• frame_count: 2 to 16 frames, default 9.
• frame_duration_ms: 20 to 2,000 ms, rounded to 10, default 200.
• size: auto or WIDTHxHEIGHT in multiples of 16. This is per frame.

Every frame has to fit inside one total request pixel budget. More frames means smaller frames. Streaming and custom compression aren't supported here either.

A minimal GIF request looks like this:

{
  "model": "gpt-image-2.6-flare",
  "prompt": "A loading spinner made of three bouncing dots",
  "output_format": "gif",
  "frame_count": 12,
  "frame_duration_ms": 80
}

Markup-guided editing

This one also works on supported 2.5 models. You send a markup field to POST /v1/images/edits: a transparent PNG with your scribbles, arrows or circles, at the exact width and height of the first input image.

Don't flatten it onto the photo. The markup applies to the first image only, and any extra images act as references. You can't combine markup with mask or prompt_rewriter, and there's no extra fee.

Real-World Use Cases

Icon and logo drafts. SVG output gives you a vector file you can open in Figma or drop into a React component. Expect cleanup, since it's generated from a raster reference first.

UI loaders and reaction GIFs. Short, small GIFs at 8-16 frames are a good fit for the pixel budget. Long, large animations aren't.

Design review loops. Markup editing lets a reviewer circle a button and write make this blue without anyone writing a mask. That could save product teams real time.

Bulk thumbnails, carefully. If cost per image is your main metric, benchmark 2.5 low against 2.6 low before switching. The 2.6 image may be better, but it's no longer the cheap option.

Hard Limitations and Flaws

The price change is hidden in a multiplier. The output token rate matches what the calculator uses for 2.5. Unless you read the calculator, you'll find out from your invoice.

SVG cost is a black box. The authoring model isn't named, and its rate isn't published.

Sunburst vs Flare isn't documented. Two models, one price, two taglines. You'll have to test them yourself.

Some 2.5 docs don't mention 2.6. Transparent backgrounds and the custom size rules are documented for 2.5 by name. Until OpenAI says otherwise, test before you rely on them with 2.6.

No Batch API. Both models list Batch as unsupported, so there's no batch discount for large overnight jobs.

Verdict: Your Developer Action Plan

GPT Image 2.6 is a real upgrade if you need vectors, animation or markup edits. It's a quiet price increase if you live at low or medium quality.

1. Pin your model ID. Keep your current 2.5 model in production until you've compared output and cost on your own prompts.
2. Re-price low and medium jobs. Multiply your current per-image cost by 4.2 (low) or 3.3 (medium) to estimate 2.6.
3. Try complexity: low first for simple assets. It's free to change, and the default is high.
4. Budget SVG separately. Track real per-request cost for a week before promising anyone a unit price.
5. Test Sunburst and Flare side by side. Same prompts, same quality, then choose on output, not the name.

The output rate didn't change, but the per-image cost did. Read the calculator before you switch.