GPT Image 2.6 guide: adjustable complexity, SVG and animated GIF output with Sunburst and Flare

GPT Image 2.6 shipped through the official changelog on 2026-11-04 and is the current image generation and editing family on the Images API. Where the 11-01 SDK documentation strings were the only trace of these models, both model cards, the dedicated guide section, and the pricing page were fully fetchable while writing this piece (2026-11-09) — every parameter rule, price, and endpoint statement below lands on official text. Fact sources are the official changelog, the Sunburst and Flare model cards, the image generation guide (.md full-text variant), and the pricing page, all fetched today; code samples are reproduced from the official guide (documentation-checked; we did not run live generation requests).

1. Release and SDK timeline

The changelog entry for 2026-11-04 (Feature, labeled Models gpt-image-2.6-sunburst and gpt-image-2.6-flare, APIs v1/images/generations and v1/images/edits) reads:

Released GPT-Image-2.6 Sunburst and GPT-Image-2.6 Flare for image generation and editing, with adjustable complexity, SVG generation, and animated GIF generation. Added markup-guided editing for supported GPT Image 2.5 and 2.6 models.

The SDKs followed a day later: openai-python v3.46.0 #4247 and openai-node v7.51.0 #3114, both titled "add image complexity and GIF and SVG output controls" in their release notes (re-verified 2026-11-09). Upgrade to those versions or above and the complexity plus GIF/SVG output controls become available in the image parameters.

2. The two models: positioning, snapshots, and endpoints

The two cards differ in their positioning lines. The Sunburst card's summary line reads "Image generation and editing for detailed visual work," with the body pointing at detailed compositions and image editing workflows; the Flare card's summary line reads "Image generation and editing for fast iteration," with the body pointing at interactive generation and editing. Beyond the positioning lines the cards are structurally identical:

Endpoint support is a hard boundary: image models are not called through the Responses API, Chat Completions, Batch, or fine-tuning — every row in the cards' endpoint tables other than image generation and editing is marked Not supported, and the pricing page's Batch table has no 2.6 rows, consistent with the cards.

3. Pricing: one price sheet, same rates as 2.5

Both model cards carry the same pricing table, which matches the pricing page's standard rows (cross-checked 2026-11-09):

The guide's costs section confirms image output at $30 per million billable tokens, and markup-guided edits use the same token rates as other edits with no extra fee. These are the same five numbers the guide lists for GPT Image 2.5, and the pricing page rows for 2.5 and 2.6 match item by item — but equal rates do not mean equal cost per image, and the guide warns that token consumption can differ by model and quality setting.

4. Adjustable complexity: the three levels

complexity is 2.6's headline new parameter; it controls how much the model plans before rendering. The guide's rules:

• Values low / medium / high, identical for both models; the default is high.
• Lower complexity suits focused edits, such as changing a background or a sign; higher complexity helps with dense text, complex layouts, and relationships between objects.
• Higher complexity can increase latency and introduce unwanted changes — the official advice is to compare results for your task.
• quality is a separate setting that controls rendering quality; adjusting complexity itself has no separate fee.

The guide demonstrates the levels with a paper-cut football scene generated from one prompt at medium quality, asking readers to compare the trophy, the uniforms, and the placement of the CHAMPIONS sign as complexity changes. Two official statements about quality should be read together: the Size and quality options section frames the xhigh and max tiers as additions on the 2.5 models, while the Calculating costs section states that the quality options for GPT Image 2.6 and 2.5 Sunburst and Flare are low, medium, high, xhigh, and max.

5. Markup-guided edits: draw where the change goes

Markup editing goes through v1/images/edits: overlay a transparent PNG annotation layer on the original image (circling or marking where the change should happen) and describe the change in the prompt. The guide states this works for supported GPT Image 2.5 and 2.6 models. The Python example, reproduced from the guide (recoloring the vase circled in the overlay):

import base64
from pathlib import Path

from openai import OpenAI

client = OpenAI()
overlay = Path("markup-vase-overlay-gpt-image-2-6.png")
with open("kitchen.webp", "rb") as image, overlay.open("rb") as markup:
    result = client.images.edit(
        model="gpt-image-2.6-flare",
        image=("kitchen.webp", image, "image/webp"),
        markup=(overlay.name, markup, "image/png"),
        quality="medium",
        prompt=(
            "Recolor the striped vase inside the red circle to solid cobalt blue ceramic. "
            "Keep its shape, the dried stems, and the rest of the kitchen unchanged. "
            "Remove the red circle from the finished photo."
        ),
    )

Path("vase.png").write_bytes(base64.b64decode(result.data[0].b64_json))

The same operation with curl (also from the guide):

set -euo pipefail

curl --fail --silent --show-error https://api.openai.com/v1/images/edits \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F model=gpt-image-2.6-flare \
  -F quality=medium \
  -F 'image=@kitchen.webp;type=image/webp' \
  -F 'markup=@markup-vase-overlay-gpt-image-2-6.png;type=image/png' \
  -F 'prompt=Recolor the striped vase inside the red circle to solid cobalt blue ceramic. Keep its shape, the dried stems, and the rest of the kitchen unchanged. Remove the red circle from the finished photo.' |
  jq -er '.data[0].b64_json' | base64 --decode > vase.png

Two details in the example matter: the prompt explicitly asks to remove the red circle from the finished photo — the annotation guides the edit and must not survive into the result; and the overlay is a transparent PNG whose dimensions match the orientation-corrected original. The guide also sets hard constraints: markup applies to the first input image (additional images serve as references), the annotation layer and the first image may each contain at most 16,777,216 pixels, the annotation file is capped at 50 MB, and markup must not be combined with a mask.

6. SVG output: editable vectors, generations endpoint only

Set output_format to "svg" on v1/images/generations to produce SVG, aimed at graphics that need editable paths, shapes, and colors, such as icons and illustrations. The rules, all from the guide:

• n must be 1.
• No streaming, partial images, or output_compression.
• The edits endpoint does not support SVG output, and an SVG is not a supported raster input for image edits.
• Mechanism: the API creates a reference image and uses it to produce the SVG, with the quality setting controlling that reference image; you pay the image model's rate for the reference image plus the authoring model's rate for the tokens it uses to produce the SVG.
• Output: decode data[0].b64_json from base64 and save the resulting UTF-8 XML bytes with an .svg extension; the document contains static vector content only — no scripts, external resources, or embedded raster images.

The guide compares both models on the same Field & Flour bakery logo prompt: the Flare and Sunburst SVGs differ visibly in composition elements (the loaf, wheat sprigs, rolling pin).

7. Animated GIF output: frame count, duration, and the pixel budget

With output_format set to "gif", both the generations and edits endpoints are supported — to guide the animation with still reference images, send them to the edits endpoint. Your prompt should describe the subject, the motion, and the desired loop. The GIF-specific request fields (the guide's own table):

size describes each finished frame. The frame count, frame dimensions, and the number of animations must all fit the model's size limits and the total request pixel budget — the guide's reduction order when a request exceeds them is: reduce frame_count, reduce the frame dimensions, or reduce n; with auto, the API picks a frame size within the model's limits. Decode each result's b64_json and save the bytes with a .gif extension. GIF output likewise does not support streaming, partial images, or custom output_compression, and frame_count with frame_duration_ms are only for GIF output. The guide's demo: a lantern-lifting monkey at frame_count=9 and frame_duration_ms=200, back at its starting pose after 1.8 seconds.

The base generation flow matches the guide's generic example (which stars gpt-image-2.5-sunburst; same endpoint, same parameter shape):

from openai import OpenAI
import base64

client = OpenAI()

prompt = """
A children's book drawing of a veterinarian using a stethoscope to
listen to the heartbeat of a baby otter.
"""

result = client.images.generate(model="gpt-image-2.5-sunburst", prompt=prompt)

image_base64 = result.data[0].b64_json
image_bytes = base64.b64decode(image_base64)

# Save the image to a file
with open("otter.png", "wb") as f:
    f.write(image_bytes)

8. Common errors and troubleshooting

• You got a bitmap instead of an SVG: confirm output_format is svg and n is 1, and that the request went to the generations endpoint — edits does not produce SVG.
• The SVG has no animation or scripts: that is the design, not a bug — the output is static vector content with no scripts, external resources, or embedded raster images.
• The GIF request fails: check the three budget items — frame_count within 2–16, frame_duration_ms within 20–2000, and the total pixels within the model's limits; reduce the frame count, frame dimensions, or n.
• The loop feels off: the official advice is to describe the subject, the motion, and the desired loop in the prompt; still reference images go through the edits endpoint.
• Results got messier after raising complexity: the guide itself warns higher complexity can introduce unwanted changes; step back down a level or compare quality settings.
• Calls through Responses or Batch do not work: image models do not run on those endpoints — every endpoint other than generations and edits is Not supported on the cards.

9. Next steps

• Where these two cards sit as official replacements (gpt-image-2 was announced deprecated on 2026-11-10 with shutdown 2027-02-10, and this card is what the replacement row points to): GPT Image 2 deprecated: API removal on February 10, 2027, official replacement is GPT Image 2.6.
• The previous generation's parameter rules (xhigh / max quality, arbitrary resolutions, transparent backgrounds): GPT Image 2.5 Explained: sunburst and flare, xhigh/max Quality, Arbitrary Resolutions.
• Prompt formulas and commercial use boundaries: GPT Image 2 Prompt Formulas and Commercial Use Boundaries.
• Cross-model selection: GPT Image 2 vs Midjourney vs DALL·E 3: Three Image Generation Models in Practice (2026).
• The continuously updated release timeline: OpenAI Models Release Notes (2026, Living Document).