Table of Contents
GPT-Image-2.6 Sunburst vs Flare: the SVG and GIF guide
Ask GPT Image for a logo last month and you got a PNG, then you traced it in Illustrator if you needed an actual vector. As of November 4, 2026, you can ask for the SVG directly, and for an animated GIF in the same request shape. OpenAI shipped both formats through GPT-Image-2.6 Sunburst and GPT-Image-2.6 Flare, two image models that replace the 2.5 pair from September. The feature list reads like a bigger deal than it is in one spot and a smaller deal than it looks in another: SVG output quietly bills two models instead of one, and the whole thing is API-only, with no ChatGPT consumer parity yet.
This is the setup for both new formats, the one pricing detail that changes how you'd actually use SVG output, and which of the two models to reach for.
What actually shipped
Sunburst and Flare are a swap-in pair, not a tiered product. Per OpenAI's model pages, gpt-image-2.6-sunburst is billed as "image generation and editing for detailed visual work" and gpt-image-2.6-flare as the same thing "for fast iteration." Both run through the same endpoints, both take the same parameters, and both cost the same per token:
| Token type | Rate (per 1M tokens) | Source |
|---|---|---|
| Text input | $5.00 | OpenAI, GPT-Image-2.6 Sunburst page |
| Cached text input | $1.25 | OpenAI, GPT-Image-2.6 Flare page |
| Image input | $8.00 | OpenAI model pages, cited above |
| Cached image input | $2.00 | OpenAI model pages, cited above |
| Image output | $30.00 | OpenAI model pages, cited above |
Those are the identical rates GPT Image 2.5 Sunburst and Flare launched with in September, so the new formats landed at no price premium on the token meter. What changed is what you can ask the model to return, and the quality ladder: Sunburst and Flare both add xhigh and max quality tiers on top of the old low/medium/high set.
One thing OpenAI does not publish: a speed or quality benchmark that separates the two. Both model pages list "Performance: Not specified" and "Speed: Not specified." The split between Sunburst and Flare is a documented intent, not a measured number, so don't go looking for a throughput chart to confirm it.
Generating an SVG directly
Set output_format: "svg" on a normal generate call. Per OpenAI's image generation guide, SVG output comes with three hard constraints: n must be 1, there's no streaming or partial images, and the edit endpoint flat out doesn't support SVG, in either direction (you can't get one out, and you can't feed one in as a reference).
import base64
from openai import OpenAI
client = OpenAI()
result = client.images.generate(
model="gpt-image-2.6-sunburst",
prompt="A minimalist logo for a bakery called Field & Flour: a wheat sprig, a loaf, clean wordmark.",
output_format="svg",
quality="medium",
n=1,
)
with open("field-and-flour.svg", "wb") as f:
f.write(base64.b64decode(result.data[0].b64_json))Here's the part worth slowing down on. The model doesn't synthesize vector paths from scratch. Per OpenAI's docs, "the API creates a reference image and uses it to produce the SVG," and the quality setting you pass controls that reference image, not the vector pass. That means an SVG request is two billed jobs stacked into one call: the image model renders a raster reference at your chosen quality, then a second authoring pass turns it into vector paths. OpenAI's own line on cost is blunt about it: "you pay the image model's rate for the reference image and the authoring model's rate for the tokens it uses to produce the SVG. The total depends on how many tokens each model uses." A quick icon in low quality is still cheap. A dense, detailed SVG at high or xhigh is not a cheap trace job, it's a full render plus a second model's worth of tokens on top.
OpenAI's own worked example for this is a Field & Flour bakery logo, generated as an SVG from the same prompt on both Flare and Sunburst. Flare's version is a simpler golden loaf over a two-line wordmark. Sunburst's adds a steaming loaf, wheat sprigs, and a rolling pin around the same wordmark, more detail for the same prompt, which lines up with "detailed visual work" being the actual difference, not a marketing label.
Generating an animated GIF
Set output_format: "gif" on either /v1/images/generations or /v1/images/edits. The GIF-specific fields are frame_count and frame_duration_ms:
| Field | Range | Default | Source |
|---|---|---|---|
frame_count | 2 to 16 frames | 9 | OpenAI's image generation guide |
frame_duration_ms | 20 to 2000ms, rounded to 10ms | 200 | same guide |
size | auto or WIDTHxHEIGHT, multiples of 16 | auto | same guide |
import base64
from openai import OpenAI
client = OpenAI()
result = client.images.generate(
model="gpt-image-2.6-sunburst",
prompt=(
"A monkey in a green coat lifts a glowing lantern, blinks, "
"and lowers it again in front of a snowy cabin. Loop smoothly."
),
output_format="gif",
frame_count=9,
frame_duration_ms=200,
)
with open("lantern.gif", "wb") as f:
f.write(base64.b64decode(result.data[0].b64_json))OpenAI's own lantern example runs exactly those settings, 9 frames at 200ms, for a loop that resolves in 1.8 seconds. GIF shares the no-streaming, no-partial-images limits from SVG, plus its own ban on custom output_compression, but it drops SVG's edit-endpoint lockout. Send the prompt and a still image to /v1/images/edits and Flare or Sunburst will animate from that starting frame instead of inventing one.
Markup-guided edits ride along, on 2.5 and 2.6 both
The same November release documents a third capability that isn't new to 2.6 specifically: markup-guided edits, which OpenAI says work on "supported GPT Image 2.5 and 2.6 models". Instead of a pixel mask, you send a transparent PNG annotation layer circling or sketching the area to change, as a separate markup field alongside the source image:
import base64
from pathlib import Path
from openai import OpenAI
client = OpenAI()
overlay = Path("markup-vase-overlay.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 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 annotation PNG has to match the source image's dimensions and stay genuinely transparent (not flattened onto a copy of the photo), and it only applies to the first input image in the request. Markup and mask are mutually exclusive on the same call. Per OpenAI's pricing notes, markup-guided edits bill at the same rate as any other edit, no extra fee the way SVG output carries one.
The gotchas
A few things the changelog entry doesn't lead with:
- No ChatGPT consumer parity yet. The release is API-only. If your use case is "my team wants to generate GIFs in the ChatGPT app," that isn't live.
- SVG and GIF formats are documented against the Images API, not the Responses API tool. If you're currently calling Sunburst or Flare through the
image_generationtool in a Responses API request, theoutput_format: "svg"and"gif"examples in OpenAI's docs are all shown againstclient.images.generate()andclient.images.edit()directly. Switch to the Images API endpoints for the new formats. - Org verification still gates access. Per OpenAI's image generation guide, you may need to complete API Organization Verification in your developer console before GPT Image models respond at all, same requirement as the 2.5 generation.
- Latency and consistency limits are unchanged. OpenAI's own limitations section still lists complex prompts taking up to two minutes, imperfect text placement, and drift on recurring characters or brand elements across generations.
What this replaces
For SVG output, OpenAI isn't first to market. Recraft's V3 vector model has generated native SVG from a text prompt for a while, at $0.08 per vector image as of a September 2026 price list, versus a per-token bill on GPT-Image-2.6 that depends on your prompt and quality tier. If vector output is your main job, Recraft is a real alternative worth pricing against your own usage before committing to OpenAI's two-model SVG tax.
Animated GIF is the less crowded corner. Mainstream text-to-image APIs return static raster frames; getting a loop normally meant reaching for a video model like Runway or Pika and then extracting frames into a GIF by hand. GPT-Image-2.6 returns the finished loop from one call with frame_count and frame_duration_ms as the only knobs, which is a smaller lift for a short product teaser or a reaction GIF than standing up a video pipeline for the same output.
Which one to pick
For a vector logo, icon set, or anything headed to a design tool, Sunburst at high or xhigh complexity is the right default; you're already paying the two-model SVG surcharge, so spend it on the model built for detail. For quick social drafts, placeholder art, or iterating on a prompt before you commit to a final render, Flare at low or medium quality is cheaper in practice because it uses fewer tokens to get to a usable frame, even though the per-token rate is identical. For animated GIFs, start with Flare for throwaway previews and move to Sunburst only once you've locked the prompt and just need the final loop to look sharp.
If your pipeline runs through the Responses API image_generation tool today, budget time to move the SVG and GIF calls to the Images API directly. That's the one piece of this release that isn't a drop-in swap.