OpenAI Images 2.6 API Guide: Flare, Sunburst, GIF/SVG, and Markup Edits

GPT-Image-2.6 Flare and Sunburst launched on the API on 2026-11-04. This guide walks through model selection, GIF/SVG output parameters, the difference between complexity and quality, markup-guided editing, the Batch API limitation, and a runnable integration example.

NixAPI Team November 10, 2026 ~11 min read
OpenAI Images 2.6 API guide: Flare vs Sunburst selection, GIF and SVG parameters, complexity control, and markup-guided editing

Introduction: This Update Is More Than “GIFs Now Exist”

On 2026-11-04, OpenAI released Images 2.6, with two models landing on the API simultaneously:

Model IDPositioning
gpt-image-2.6-flareSpeed first — fast iteration, interactive generation and editing
gpt-image-2.6-sunburstDetail first — dense compositions, text-heavy layouts, cross-edit consistency

OpenAI claims roughly 50% faster generation overall, with Flare returning a low-quality image in as little as 6 seconds. New capabilities include GIF output, SVG export, markup-guided edits, and a complexity parameter.

But for developers, the important part isn’t the feature list. It’s these three shifts:

  1. Control dimensions doubled — quality governs rendering fidelity, complexity governs planning effort; they’re independent;
  2. Output shapes expanded from still images to animations and vector files — which changes material-production workflows;
  3. The Batch API is gone for 2.6 — 2.5 supports it, with image output at half price ($15 vs $30 per 1M).

Cost note: this article covers integration and parameters. 2.6’s low and medium tiers actually cost 3–4× more than 2.5 despite an identical rate card. The full breakdown is in the companion piece: OpenAI Images 2.6 Real Cost.

1. Flare vs Sunburst: How to Choose

Both models have identical pricing (same rate card), so selection comes down to latency and consistency.

Dimensiongpt-image-2.6-flaregpt-image-2.6-sunburst
PositioningSpeedDetail
LatencyAs little as 6 seconds at low qualitySlower; OpenAI publishes no figure
Layout qualityImproved layouts for posters, product imageryDense compositions, text-heavy layouts
Cross-edit consistencyAverageStronger at medium/high (same character or product across 5 edits without drift)
PriceSame rate cardSame rate card

Decision rule

  • Exploration (need 10 layout variants, iterating with users) → Flare; iteration speed is the product experience;
  • Delivery (same character, five successive edits, consistency required) → Sunburst; consistency is a hard requirement;
  • Don’t route everything through Sunburst just because it’s “higher quality” — at the low tier it gives you no quality benefit, only a latency penalty.

Testing note: 2.6 Sunburst may be slower than 2.5 Sunburst at equivalent quality. OpenAI’s “50% faster” headline mostly applies to Flare and the higher quality tiers. If your pipeline has a latency SLA, measure it.

2. Core Parameters: quality and complexity Are Different Dimensions

This is the most commonly misunderstood part of the release.

2.1 What Each Controls

ParameterControlsValuesDefault
qualityRendering detail and fidelitylow / medium / high / xhigh / max / autoauto (medium on some channels)
complexityPlanning effort before rendering — how many elements, layers, and relationshipslow / medium / highhigh

OpenAI is explicit: “Adjusting complexity has no separate fee.”

But it does add latency, and OpenAI warns that higher complexity can introduce unwanted changes.

2.2 How to Pair Them

ScenarioqualitycomplexityNotes
Background or sign swaplowlowLocal edit; low planning avoids collateral changes
Icons, simple diagramslowlowClean and minimal; visual noise hurts legibility
Product marketing, docs imagerymediummediumBalanced
Posters, multi-object sceneshighhighMany elements, complex relationships

The default complexity: high is a trap. Plenty of integrations just omit the parameter, which means every generation runs at maximum planning effort — higher latency, higher cost (planning affects output token count), and on simple local edits a greater chance of “changing more than you asked.” Setting complexity explicitly should be day-one work.

2.3 A Runnable Example

import openai

client = openai.OpenAI()  # or base_url="https://api.nixapi.com/v1"

resp = client.images.generate(
    model="gpt-image-2.6-flare",
    prompt="Minimal line-art coffee cup icon, dark grey strokes, transparent background",
    quality="low",
    complexity="low",          # don't omit! default high plans maximally
    size="1024x1024",
    output_format="png",
)

# Whether usage comes back depends on the channel
print(resp.data[0].b64_json[:32], "...")

cURL version:

curl https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "Minimal line-art coffee cup icon, dark grey strokes, transparent background",
    "quality": "low",
    "complexity": "low",
    "size": "1024x1024",
    "output_format": "png"
  }'

3. GIF Output: Parameters and the Cost Trap

3.1 Three Parameters

curl -s \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "A paper plane looping once, flat style",
    "output_format": "gif",
    "frame_count": 9,
    "frame_duration_ms": 200,
    "quality": "high",
    "complexity": "low"
  }' > plane.json

jq -r '.data.b64_json' plane.json | base64 --decode > plane.gif
ParameterRangeDefault
output_formatpng / jpeg / webp / gif / svgpng
frame_count2 – 169
frame_duration_ms20 – 2000200

Default is 9 frames × 200 ms = a 1.8-second loop.

3.2 The Frame-Size Rule Nobody Mentions

All frames are drawn on a single sheet, and that sheet is bound by the same pixel limit as a single image.

Practical consequences:

  • At 16 frames, per-frame size caps at 720×720 (16 frames have to compose into one large sheet);
  • the more frames you request, the lower your per-frame resolution.

If you need a “large, sharp animation,” frame count and resolution trade off directly. A 1080p-class animation can only have a handful of frames.

3.3 Cost: GIFs Bill by Combined Area

A GIF costs the same as a single image of the combined area of all its frames.

Measured figures:

GIF configurationCost
12 frames 512×512 (medium)$0.055
12 frames 512×512 (high)$0.067
16 frames 720×720 (max size, high)$0.147

A 12-frame 512×512 GIF ($0.055) costs more than one 1024×1024 static image ($0.044). For bulk animation, recalculate expectations by frame count — static-image intuition doesn’t transfer.

3.4 Two More Notes

  • API-generated GIFs loop forever — there’s no “play once and stop” option;
  • Observed file sizes run roughly 0.5 – 1.5 MB.

4. SVG Output: When It’s Worth It

2.6 can return a vector file directly.

Good SVG candidates:

  • Icons, logos, simple illustrations — scale losslessly from app icon to billboard;
  • Assets that need to scale inside a web app;
  • Design-tool workflows where individual paths stay editable.

Poor SVG candidates: complex textures, photographic content, gradient-heavy illustration — raster is the better tool there.

resp = client.images.generate(
    model="gpt-image-2.6-flare",
    prompt="A minimal lightning bolt icon, single color, clean lines",
    output_format="svg",
    quality="low",
    complexity="low",
)
svg = resp.data[0].b64_json  # base64-encoded SVG

Channel differences: some third-party aggregators (e.g. AI/ML API) don’t support SVG output yet — their format set is PNG/JPEG/WebP/GIF. If your pipeline depends on SVG, verify your target channel actually honors output_format: "svg" before building on it.

5. Markup-Guided Editing: Telling the Model Where

This is the most practically valuable feature of the release, and a genuine paradigm shift in image editing.

5.1 The Old Pain Point

Describing where to edit has always been the weak spot:

“Move the lamp on the left a bit — no, the other lamp”

Nobody wants to write that sentence.

5.2 How Markup Works

Supply a second transparent PNG as a markup layer, after the first input image, with a circle or arrow drawn on the region you want changed.

resp = client.images.edit(
    model="gpt-image-2.6-sunburst",
    image=[
        open("original.png", "rb"),   # first: the original
        open("markup.png", "rb"),     # second: transparent markup layer
    ],
    prompt="Change the circled desk lamp to black metal; keep everything else identical",
    quality="high",
    complexity="low",     # local edit -> low planning
)

Three practical notes:

  1. The second image must be a transparent PNG with marks like a red circle or an arrow;
  2. It applies to the first image — order matters;
  3. Use complexity: low for local edits; less planning means fewer accidental changes.

5.3 2.5 Supports This Too

OpenAI’s changelog states: “markup-guided editing for supported GPT Image 2.5 and 2.6 models.”

That matters: if you’re already on 2.5, you don’t need to migrate to 2.6 for markup editing. Only GIF and SVG are exclusive to 2.6.

6. Sizes, Batch, and Limits

6.1 Custom Dimensions

PropertyValue
StepMultiples of 16 pixels
Aspect ratio1:3 to 3:1
Long edge3,840 px
Total pixels8,294,400 (4K)
Official statusSizes above 2560×1440 are marked experimental

6.2 Batch API: Not Supported

This is the change with the biggest impact on production pipelines:

Images 2.5Images 2.6
Batch endpoint supported not supported
Batch image output rate$15 / 1Mnot listed

The Flare model page lists only two endpoints: image generation and image edit. Batch is marked unsupported.

If your current pipeline is “generate thousands of assets in an overnight batch”:

  • 2.6 cannot drop into 2.5’s place;
  • and 2.5’s Batch is half price — which widens 2.5’s cost advantage in bulk;
  • migration requires rebuilding around concurrent calls plus your own retry queue.

6.3 The usage Field: Verify Before You Build Cost Tracking

The API reference’s usage object description still says it applies to gpt-image-1 only.

That means: don’t assume 2.6 responses carry usage. Third-party testing has also observed 2.6 responses without a usage field.

If you’re building cost tracking, verify on day one:

resp = client.images.generate(
    model="gpt-image-2.6-flare",
    prompt="A simple test image",
    quality="low",
)
print("has usage:", hasattr(resp, "usage"))
print(resp.usage if hasattr(resp, "usage") else "NO USAGE FIELD")

Without usage, you can’t bill by actual tokens — only estimate by tier, which is exactly where cost drift comes from.

7. Migration Checklist from 2.5

CheckVerdictAction
Need GIFImpossible on 2.5Migrate to 2.6
Need SVGImpossible on 2.5Migrate to 2.6
Need markup editing2.5 supports itNo migration needed
Using Batch API2.6 unsupportedStay on 2.5, or rebuild with concurrency + retries
Bulk low/medium quality2.6 is 3–4× pricier with no Batch discountStay on 2.5
High quality tierSame cost, ~50% fasterMigrate freely
Need reproducible snapshots2.6 has no dated model stringAdd your own output cache
Cost tracking depends on usageDocs say gpt-image-1 onlyVerify before shipping

8. Where a Unified Endpoint Actually Helps

Images 2.6 introduces new output shapes (GIF, SVG), a new control dimension (complexity), and new sizing rules (16px steps, 4K, 1:3–3:1) — while channel support varies:

  • SVG output isn’t universal;
  • usage presence differs by channel;
  • Batch support may differ too.

That’s exactly the kind of problem a unified API layer solves:

  1. Verifiable parameter passthrough — new parameters like complexity, frame_count, and frame_duration_ms can be silently dropped in transit; you want a layer that echoes back what actually arrived;
  2. Capability probing — the gateway can detect which output_format values a target channel supports at onboarding time, instead of failing at runtime;
  3. Unified billing — real token counts come from usage, so the unified view bills on measured usage, not tier estimates;
  4. Workload routing — route by job type: bulk icons → 2.5 Batch; final deliverables → 2.6 Sunburst; exploration → 2.6 Flare.

Live model list and current pricing: NixAPI pricing.

9. Conclusion

The Images 2.6 feature list is genuinely appealing — GIF, SVG, markup editing, complexity. But three things matter more for developers:

  1. complexity defaults to high and costs nothing extra — but adds latency and can introduce unwanted changes. Setting it explicitly is day-one work.
  2. 2.6 has no Batch API, while 2.5’s Batch is half price — bulk production has no migration reason yet.
  3. Markup editing works on 2.5 too — only GIF and SVG are actual reasons to migrate.

One last reminder: this article skips the cost detail because 2.6’s low and medium tiers cost 3–4× 2.5, which deserves its own piece. Full numbers: OpenAI Images 2.6 Real Cost.


Further reading:


This article was written by the NixAPI editorial team. NixAPI is a unified aggregator for multiple LLM APIs, supporting 30+ models including OpenAI / Anthropic / Google / DeepSeek. Console registration includes a $1 trial credit.

Try NixAPI Now

Reliable LLM API relay for OpenAI, Claude, Gemini, DeepSeek, Qwen, and Grok with ¥1 = $1 top-up

Sign Up Free