OpenAI Images 2.6: Now Faster, with Support for GIFs

Until last week, getting a moving image out of ChatGPT meant asking for a sprite sheet, downloading it, and fixing the frames together yourself in some other tool. I did this more often than I'd like to admit. 

On November 4, OpenAI released Images 2.6, and now you type "make a gif of a cat dancing" and get a looping GIF back.

GIFs are the headline, but they aren't the whole release. OpenAI says images now generate 50% faster, edits hold onto characters and products better, and the API splits into two models with different jobs. 

In this article, I'll cover what Images 2.6 is, what changed, and how to make a GIF in both ChatGPT and using the API. 

What's New in OpenAI Images 2.6?

OpenAI Images 2.6 is OpenAI's November 4, 2026 image update for ChatGPT, Codex, and the API. The main changes include:

• Animated GIFs: Turn a prompt, photo, or sketch into a short looping GIF, then change its speed or edit single frames.

• Faster generation: OpenAI claims images generate 50% faster than Images 2.5.

• Steadier edits: Characters, products, and brand details drift less across editing rounds.

• Two API models: Use gpt-image-2.6-flare for speed and gpt-image-2.6-sunburst for detail.

• Smaller additions: Export images in SVG, do markup-guided edits in the API, reference saved images, and use its complexity parameter.

It's available on every ChatGPT plan, including Free, though GIF creation is rolling out to accounts gradually.

What Is OpenAI Images 2.6?

OpenAI Images 2.6 is the image generation and editing release OpenAI released on November 4, 2026. It’s available as the image tool inside ChatGPT and Codex and as two separate models in the OpenAI API.

In ChatGPT, you can’t select a model of your choice or switch between its models, Flare and Sunburst; you just type a request, and it generates a GIF. But with the API, you can choose between two models by name, and control settings such as quality and complexity yourself.

Both API models cost the same per token, and those rates match the Images 2.5 models. So the choice between Flare and Sunburst comes down to speed versus detail, not price. Per-image cost still varies because higher-quality settings use more output tokens.

Suppose a coffee brand wants a short looping GIF of its mascot, a cartoon coffee cup, waving hello.

• In ChatGPT (a marketer): She types “Make a looping GIF of our coffee-cup mascot waving hello.” ChatGPT picks the model and makes the GIF. If it’s too slow, she types “make it faster” in the chat. She doesn’t edit any settings, and pays nothing beyond her ChatGPT plan.

• With the API (a developer): He’s adding a “Make a GIF” button to the brand’s app, so he writes the code himself. He selects gpt-image-2.6-flare because it’s the faster model, sets output_format: "gif", and chooses the frame count and quality. Each GIF is billed by tokens, so higher quality costs more per image.

What’s New in OpenAI Images 2.6?

Images 2.6 adds animated GIFs, faster generation, steadier multi-round edits, and better layouts for professional visuals. 

Is OpenAI Images 2.6 really faster?

OpenAI says Images 2.6 generates images 50% faster than Images 2.5, and that gpt-image-2.6-flare can return a low-quality image in as little as six seconds. That’s a bold claim, and the announcement doesn’t explain how it was measured. So I tested it myself.

I gave Flare and Sunburst the same prompt, “A ceramic coffee mug on a wooden desk, morning light, product photo,” at 1024x1024 with complexity set to low. Flare ran at both low and medium quality, since low is the setting behind OpenAI’s six-second claim, and Sunburst ran at medium. 

Each setup ran five times, and I kept the median, because one slow response can throw off an average. Then I repeated the whole test, since network speed changes from run to run and I didn’t want one lucky (or unlucky) afternoon to decide the result.

If you want to check my numbers against your own, here’s the script I ran in Google Colab:

import statistics
import time

from openai import OpenAI

# Reads OPENAI_API_KEY from your environment
client = OpenAI()
prompt = "A ceramic coffee mug on a wooden desk, morning light, product photo."

# Each setup: (model, quality)
setups = [
    ("gpt-image-2.6-flare", "low"),
    ("gpt-image-2.6-flare", "medium"),
    ("gpt-image-2.6-sunburst", "medium"),
]

for model, quality in setups:
    times = []
    for _ in range(5):
        start = time.perf_counter()
        client.images.generate(
            model=model,
            prompt=prompt,
            size="1024x1024",
            quality=quality,
            extra_body={"complexity": "low"},  # skip extra planning for a simple scene
        )
        times.append(time.perf_counter() - start)
    # The median ignores one unusually slow or fast request
    print(model, quality, round(statistics.median(times), 1), "s")
Powered by

Here’s what I got:

Flare never got under OpenAI’s six seconds; my best median was 6.9. That’s not quite a broken promise, since “as little as” describes the best case, not the typical one. The second run also flipped low and medium quality, with Flare at medium finishing faster than at low. 

At this size, the quality setting barely changes Flare’s speed, and network noise is bigger than the difference.

Sunburst is the slow one, and that held both times: 14.5 and 15.8 seconds, about twice as long as Flare.

Remember the complexity setting from earlier? 

It controls how much the model plans before rendering, and it defaults to high. OpenAI’s six-second figure almost certainly assumes it’s set to low, which is why I tested it that way. Leave it unset, and you’re paying for planning time on a mug photo that doesn’t need it.

Faster doesn’t mean cheaper, though. A low-quality 1024x1024 image uses 823 output tokens in 2.6 versus 196 in 2.5. The per-token price didn’t change, so at $30 per 1M output tokens, that’s roughly $0.025 per image instead of $0.006. Small per image, not small across 10,000 of them.

How much more consistent is image editing?

According to OpenAI, Images 2.6 keeps more of an image unchanged when you edit one part of it, especially across several rounds of edits. Sunburst is the model it recommends for this because, at medium or high quality, it holds details steadier from one edit to the next.

Here’s what “consistent” covers in practice:

To test this, I generated a perfume bottle with gpt-image-2.6-sunburst at medium quality, then changed only the background three times: a beach, a night sky, and a kitchen shelf. 

Each edit started from the previous result, not the original, so any drift would pile up. Every edit prompt ended the same way: “Keep the bottle, label, cap, and lighting on the bottle exactly the same.”

Here's the original next to the third edit:

The original: a green bottle with a gold cap on a marble counter. Image by Author.

After three rounds, the bottle came through almost untouched. The label still reads “MOSS No. 3” in the same serif type and gold border, and the cap, the square shape, and even the thin tube inside the glass all match the original.

What did change was everything around it:

• The background carried over: I asked for a night sky in round 2 and got round 1’s beach at night, palm tree included. Since each edit builds on the last image, Sunburst treated the beach as something to keep, and only the kitchen in round 3 finally cleared it. The marble counter survived all three edits too, which I hadn’t asked for. Fair enough; it’s what the bottle stands on.
• Lighting stayed exactly as I asked, and that was the problem: Sunburst took my prompt literally, so the bottle is lit like a sunny afternoon under a full moon, with the same hard shadow in every scene so it looks pasted in.

Still, for product shots, this is the consistency people have been asking for. Just don’t tell it to keep the lighting when the scene’s light should change.

Are professional visuals like posters better?

For layout work like posters and product images, OpenAI pitches Flare, not Sunburst. Flare is supposed to place text, images, and spacing more deliberately, while Sunburst is meant for fine detail and consistency. 

That surprised me a little. You’d expect the faster model to be the sloppier one, so I put both on a poster to see.

I gave both models the same prompt at medium quality and a portrait 1024x1536 size: “A poster for a Saturday farmers market. Title: ‘Riverside Market’. Subtitle: ‘Every Saturday, 8 AM to 1 PM’. Illustrated vegetables at the bottom, clean sans-serif type.”

See the results below: Flare on the left, Sunburst on the right:

Flare and Sunburst poster comparison. Image by Author.

Every word came out right on both, which I didn’t expect from either. They also read “Riverside” literally and painted a river with a bridge behind the vegetables, though I never asked for one.

The difference is in how much each one adds: 

• Flare kept it simple with a huge title, the subtitle in a green pill, then vegetables. You could read it from across the street. 

Sunburst built a whole scene, with market stalls, sunflowers, a tree, and a yellow ribbon banner, and it looks more like a finished illustration.

Sunburst took three times as long. For a poster, where people need to read the title and walk on, I’d take Flare’s version.

What can you do with animated GIF generation?

Images 2.6 turns a text prompt, an uploaded photo, or a rough sketch into a short looping GIF. In ChatGPT, you can then change the playback speed and edit individual frames without leaving the chat. Before this release, ChatGPT couldn’t make a GIF in one step.

What it’s good for:

• Animated characters: A mascot or a doodle that waves, blinks, or jumps.
• Reaction GIFs and social content: Short loops for posts and replies.
• Product animations: A still product shot becomes a loop that catches attention in a feed.
• Storyboards: Testing how a character moves before paying for video production. OpenAI was clear this isn’t a video generator; a GIF is a few frames on repeat, not a clip.

You don’t need a finished design, either. Draw a rough character, upload it, and ask it to wave. I’ll walk through that whole workflow in the next section.

What else changed?

A few smaller updates, split between the API and ChatGPT:

• SVG export (API only): Set output_format: "svg" to get vector files for websites, apps, or print.
• The complexity parameter (API): As I mentioned in the speed test, it accepts "low", "medium", or "high". Use low for simple edits like background swaps, and save high for crowded scenes with many constraints. Raising quality won’t fix a crowded scene; raising complexity might.
• Saved reference images (ChatGPT): Upload a photo of yourself, your pet, or a mascot once, and ChatGPT keeps it. In a later chat, just ask for “my cat in a spacesuit” without uploading the photo again, and the same cat shows up every time.

• Markup-guided edits (ChatGPT and API): Circle the part you want changed and say what to change, like circling a vase and writing “make it blue.” ChatGPT already had this; Images 2.6 brings it to the API.

How to Create GIFs With OpenAI Images 2.6

To make a GIF, ask for one in ChatGPT, or call the Images API with output_format: "gif". ChatGPT is quicker for a one-off, but the API gives you control over frame count and timing, which is quite important if you're making more than a handful of GIFs.

How to make a GIF in ChatGPT

Open a new chat and describe the GIF: the subject, the motion, and that it should loop. Here’s what I asked for: “Make a GIF of a small orange robot waving, then returning to its starting pose. Keep the background plain and the camera still.”

ChatGPT with Images 2.6 generates an orange robot. GIF by Author.

You can also start from something you already have. Upload a photo or a rough sketch, then say what should move and what must stay fixed.

I tried this with a child’s drawing of a bird:

A rough drawing of a bird. Image by Author.

My prompt: “Turn this child’s drawing into a looping GIF. Keep the hand-drawn style. Make the bird hop once and flap its wing, then return to its starting pose. Keep the background plain white and the camera still.”

The GIF ChatGPT made from a rough drawing. GIF by Author.

ChatGPT returned a 9-frame loop at 180 ms per frame, about 1.6 seconds, in a 183KB file. It kept the scribbly style, which I half expected it to “fix.” The bird crouches, jumps with its legs tucked, and lands.

My favorite detail is one I never asked for. The one-line wing grows into a real wing for the flap, then folds back into a curve when the bird lands. ChatGPT even added little motion lines, the way a kid would.

Those last three frames are nearly identical, so the bird pauses before the next hop. That pause hides the loop point well, though if you watch closely, the bird shifts slightly when it restarts.

Once a GIF is ready, you can slow it down, speed it up, or fix single frames. You don’t need the controls for this, either. Plain-language requests work, such as “Make the transition from the last frame back to the first smoother.”

How to make a GIF with the OpenAI API

Send a request to the image generation endpoint with output_format set to "gif". Two settings are specific to GIFs:

With the defaults, you get 9 frames at 200 ms each, so a 1.8-second loop.

I ran the code below in Google Colab with version 3.46 of the openai package, and it worked as written. The API matched every setting exactly, down to the 512x512 size.

import base64

from openai import OpenAI

# Reads OPENAI_API_KEY from your environment
client = OpenAI()

result = client.images.generate(
    model="gpt-image-2.6-flare",  # Flare: faster; switch to sunburst for detail
    prompt=(
        "A small orange robot waves, blinks, and returns to its starting pose. "
        "Plain white background, fixed camera, seamless loop."
    ),
    output_format="gif",
    frame_count=9,  # 9 frames x 200 ms = a 1.8-second loop
    frame_duration_ms=200,
    size="512x512",  # smaller frames keep the file size down
    quality="low",
    complexity="low",  # a simple motion doesn't need extra planning
)

# The GIF comes back as base64; decode it and save it to disk
gif_bytes = base64.b64decode(result.data[0].b64_json)
with open("robot.gif", "wb") as f:
    f.write(gif_bytes)
Powered by

image-2.6-flare API generates an orange robot waving in a loop. GIF by Author.

Compare it with the ChatGPT robot. Both show an orange robot waving, but this one looks rougher because the code sets quality="low" to save time and money. The surface looks scratched, small parts like the antennas shift between frames, and in one frame the wave turns into a thumbs-up. Low quality is fine for a quick reaction GIF in a chat. For anything with your brand on it, use "medium" or "high".

The file came out at 429KB, close to the 500KB cap many websites set for GIFs.

Before you build on it, know two limits:

• No streaming: Partial images and output_compression don’t work with GIF output either.

• A pixel budget: Frame count, frame size, and n all have to fit inside one total. If a request fails, cut one of them.

How do you get a smooth loop?

In your prompt, ask for a motion that ends where it began, and say what should stay still. If the last frame doesn’t match the first, you’ll see a jump every time the GIF starts over. Slowing it down with frame_duration_ms won’t hide that jump. Instead, ask for the action to return to its starting pose, as I did with the robot and the bird.

In practice:

• Choose one small, reversible action, such as a wave or a blink.
• Keep the camera, background, and scale fixed.
• Leave text out of the frame.
• Watch several full loops, and check the middle frames, not just the first and last. That’s where my API robot slipped in its thumbs-up.

Check the file size before you put a GIF on a website. My 512x512, 9-frame robot already came in at 429KB, so 1024x1024 at 16 frames won’t come close to a 500KB cap.

Final Thoughts

If you make GIFs for social posts, mascots, or storyboards, Images 2.6 is a big change, because you no longer need a separate tool to animate your images.

However, if GIFs aren’t your thing and you’re looking for a still-image tool, our guide to the best free AI image generators compares some good options. To see how Google is handling the same editing problems, read our Nano Banana 2 guide.