memujo
AI8 min read

OpenAI Images 2.6 Prices Two Models at One Rate

OpenAI's Images 2.6 ships Flare and Sunburst at identical token rates, so cost per image now hides in a new complexity parameter most builders will miss.

By Alice

In this article
  1. 01Context: What Actually Shipped
  2. 02The Pricing Table Nobody Parsed
  3. 03Why This Matters: The Free Knob Is the Expensive One
  4. 04What the GIF Pipeline Costs Is Undocumented
  5. 05Outlook

On November 4, OpenAI launched ChatGPT Images 2.6, its biggest image release since the original gpt-image-1 line. The consumer features got the headlines: GIF creation inside ChatGPT, reusable reference images of yourself or your pet or your brand mascot, and frame-by-frame editing of animations. But buried in the developer surface is the more interesting decision. OpenAI shipped two distinct API models, GPT-Image-2.6 Flare and GPT-Image-2.6 Sunburst, and priced them at exactly the same rates: $8.00 per million image input tokens, $30.00 per million image output tokens, $2.00 for cached image input, according to the platform pricing page.

That is unusual. When a lab ships a fast model and a quality model, the fast one is usually cheaper per token, or the quality one costs a premium. OpenAI priced its two-tier image stack as a single product and moved the differentiation somewhere else entirely: into which model you pick, which quality level you request, and a brand-new complexity parameter that, in OpenAI's own words, "has no separate fee." Read that again. The knob that changes how much compute your request consumes is free to set. The bill it generates is not.

Context: What Actually Shipped

The release has three layers, all live as of November 4 and verified across OpenAI's announcement thread, its image generation docs, and secondary coverage from TestingCatalog and RuntimeWire.

In ChatGPT and Codex, globally across every subscription tier on desktop, mobile, and web:

  • GIF creation from a prompt or an image, with adjustable speed and individual frame editing
  • Reference images you save once and reuse across generations, so characters, pets, and product shots stay consistent without re-uploading
  • Image markup, painting on the image to tell the model exactly where to change things

In the API, as gpt-image-2.6-flare and gpt-image-2.6-sunburst:

  • Flare targets speed and professional layouts, producing an image in as little as six seconds at low quality (OpenAI's claim)
  • Sunburst targets detail and consistency across successive edits at medium or high quality
  • Both support the complexity parameter, markup-guided edits via POST /v1/images/edits, SVG output, and animated GIF output
  • OpenAI claims both generate images 50% faster than the previous models, at 4 billion images per week of volume across its products (vendor-reported, no independent benchmark yet)

The Pricing Table Nobody Parsed

Here is what the platform pricing page shows today, side by side with the previous generation:

Model Image input ($/M) Image output ($/M) Cached input ($/M) Text input ($/M)
gpt-image-2.6-sunburst 8.00 30.00 2.00 5.00
gpt-image-2.6-flare 8.00 30.00 2.00 5.00
gpt-image-2.5-sunburst 8.00 30.00 2.00 5.00
gpt-image-2.5-flare 8.00 30.00 2.00 5.00
gpt-image-2 4.00 15.00 1.00 (not listed)

Three observations fall out of this table.

First, the 2.6 launch did not change list prices at all. The 2.5 pair and the 2.6 pair are identical line items, and both sit at exactly double the per-token rates of the plain gpt-image-2. If your pipeline pins gpt-image-2 for cost reasons, nothing about this release pressures you to migrate on price.

Second, Flare and Sunburst are priced identically despite being visibly different products. OpenAI's own cost calculator example shows one image at low settings consuming 823 output tokens, an estimated $0.02469 at the $30 per million rate. The docs explicitly warn that "equal token rates don't mean equal cost per image: token consumption can differ by model and quality setting." So the unit price is a fiction in the economic sense. The real price of an image is tokens consumed times rate, and OpenAI only tells you the rate.

Third, the quality ladder for 2.6 now runs low, medium, high, xhigh, and max. Five rungs, one per-token price. A "max" image plausibly consumes several multiples of a "low" image, and the calculator's 823-token figure is the floor of the range, not the middle of it.

Why This Matters: The Free Knob Is the Expensive One

From an engineering standpoint, the most consequential line in the new documentation is about complexity. It takes three values, low, medium, high, and controls "how much the image model plans before rendering." If you omit it, both models default to high. Adjusting it has no separate fee, but the docs concede that "higher complexity can increase latency and introduce unwanted changes."

Put the pieces together and you get the actual billing architecture of Images 2.6:

  1. List price per token is fixed across both models and all five quality levels.
  2. Three orthogonal dials (model choice, quality, complexity) each change compute and token consumption.
  3. Every dial defaults to the expensive end: complexity defaults to high, and the API's own guidance says low complexity suits most quick edits.

That is a cost structure where the default configuration is the worst-value configuration, and the savings require deliberate action. Anyone who has watched LLM API pricing knows this pattern. It is the same reasoning we laid out in Kimi K3.1 Pro's 33 percent price cut: sticker price is a marketing surface, and cost per completed task is the only number that survives contact with production. Images 2.6 pushes the task-level variable entirely inside your request parameters.

The data-science angle is subtler. A complexity parameter that controls "how much planning the model applies" is almost certainly exposing test-time compute scaling to image users, the same lever text models use when they reason longer on harder problems. OpenAI's framing maps directly onto it: low complexity for a focused edit (change a background, swap a sign), high complexity for dense text rendering, complex layouts, and multi-object spatial relationships. If that mapping holds, then complexity trades latency and tokens for constraint satisfaction, and the right setting is task-dependent, not aesthetic. A/B it on your own workload; OpenAI's docs literally advise "compare results for your task" rather than recommending a level.

The two-model, one-price structure also tells you something about serving economics. Maintaining Flare and Sunburst at the same rate only makes sense if OpenAI expects their marginal serving costs to land in a similar band, or if it would rather segment on latency and quality than on price. Flare at roughly six seconds at low quality looks like a smaller or fewer-step model for draft loops. Sunburst looks like the one with the extra compute for edit consistency. By refusing to price-gap them, OpenAI gets developers to route by job type instead of budget, which keeps the expensive Sunburst traffic from churning to Flare over a few cents. We covered the opposite strategy, price cuts as a competitive weapon, in OpenAI's 20 percent cut on GPT-5.6 Sol. Here the lever is product shape, not discount.

At 4 billion images per week, even small parameter effects are enormous. If the median image consumed 823 tokens at $30 per million, weekly spend on output alone would sit near $99 million (4 billion times 823 times $0.00003). If complexity defaults pushed half that volume to medium or high settings, the same nominal rate could plausibly double the compute behind it. Those are estimates built on OpenAI's own floor number, not disclosures, but they show why a silent default to high is a board-level compute decision wearing a parameter's clothing.

What the GIF Pipeline Costs Is Undocumented

The GIF feature is where the pricing docs go quiet. The API exposes frame_count from 2 to 64 frames (default 9) and frame_duration_ms from 20 to 2,000 milliseconds per frame, so a maximum-length loop is 64 frames, up to 128 seconds. GIF output works only on the generation endpoint, and SVG output does not support streaming, partial images, or the edit endpoint.

OpenAI does not state whether a 64-frame GIF bills as 64 images' worth of output tokens or benefits from inter-frame compression the way video codecs do. If frames bill near per-image rates, a default 9-frame GIF costs roughly an order of magnitude more than a still, and a maxed 64-frame GIF could clear a dollar per generation at high settings. That is a reasonable inference from the token-metered model, not a documented fact, and it is exactly the kind of cliff you should measure before you let a product team put GIF buttons in front of the API. The same discipline we applied in local AI versus API cost math applies: model the worst-case parameter combination, because users will find it.

There is also an unpriced giveaway hiding in plain sight: markup-guided edits. Painting an annotation layer onto an image is a freeform specification language for spatial intent, and it replaces the retry loops that burn tokens. One edit with markup that hits the target beats four regenerations at high complexity. The cheapest compute OpenAI shipped in this release is the one that removes generations.

Outlook

Expect third-party latency and consistency numbers for Flare and Sunburst within a week; the 50 percent speed claim and the six-second low-quality figure are vendor-reported for now, and edit consistency is notoriously hard to benchmark without a defined task suite. Watch three things. First, whether anyone publishes tokens-per-image across quality levels, which would finally expose the real price curve behind the flat rate card. Second, whether the complexity default of high survives developer feedback; OpenAI changed defaults quickly when text models burned budgets, and this default is the same shape of problem. Third, whether the pricing parity between speed-tier and quality-tier models holds through the next release, because the first price-gap between Flare and Sunburst will reveal how OpenAI actually segments its image serving costs.

For builders shipping image features today, the playbook is short. Pin explicit complexity and quality values instead of inheriting defaults, as we also recommend in the GPT-6 Astra token economics analysis for text workloads. Route drafts through Flare and only final renders through Sunburst. Log usage tokens per response per parameter combination, because that log is the only place your true cost curve exists. And benchmark a 64-frame GIF before anyone discovers it in production.

The consumer story here is real, and reference images plus frame editing genuinely move image generation from one-shot novelty into repeatable creative workflow. But the release's design center of gravity is developer infrastructure: two models, one price, three hidden dials, defaults tuned for the vendor's compute story rather than your invoice. That is a perfectly rational product decision. It just means the cost control is now entirely your job.

  • #openai
  • #image-generation
  • #api-pricing
  • #gpt-image
  • #latency
  • #developer-tools

Sources

Share this story