GPT Image 2.6 is OpenAI’s image generation and editing model family. Released on November 4, 2026, it also supports animated GIF creation, alongside improvements to generation speed and consistency across edits. The API offers Flare for fast iteration and Sunburst for more detailed visual work. OpenAI’s launch announcement
That raises an interesting question. If this is an image model, how can it produce something that moves?
The answer starts with a simple observation: an animation can be made from a sequence of still pictures. The difficult part is drawing pictures that belong together. Let’s separate that problem from the much simpler task of putting those pictures into a GIF file.
1. Start with six drawings
Imagine drawing a small cat on six cards. On the first card, its paw rests on the floor. On the next few cards, the paw rises and waves. On the final cards, it comes back down.
Show the cards in order, with a short pause between them, and the cat appears to move. Repeat the sequence, and you have a loop.
An animated GIF stores image data and playback instructions. Its graphic control extension can specify a delay before the next image is displayed; the format measures that delay in hundredths of a second. GIF89a specification
There are two separate jobs here:
- Create the animation frames. Decide what the cat looks like and how its pose changes.
- Encode the animation. Store the pictures in order, assign their delays, and configure repeating playback.
The encoder does not need to understand cats or waving. It only needs valid image data and instructions for playing it.
2. Why an image model can create animation
A single image can contain several moments. A comic strip does this. So does an animator’s sheet of poses.
An image model can be asked to draw those moments together, arranging them as panels in one composition. Each panel represents a different point in the action. Software can then extract the panels and play them in sequence.
This arrangement is called a sprite sheet: one image containing multiple smaller images. OpenAI’s launch examples explicitly request six sequential frames in a three-column, two-row grid, with matching panel sizes and a fixed camera. Official sprite-sheet examples
The useful idea is that spatial order can represent temporal order. Left to right, then top to bottom, becomes first frame, second frame, and so on.
This helps explain why image generation can support short animations. The task includes drawing related poses within a shared visual composition, followed by ordinary animation processing.
It also explains why “generate nine unrelated pictures and combine them” is an incomplete description. Independent requests can make different choices about the character’s proportions, lighting, camera position, or background. An animation request needs those choices to stay consistent while the action changes.
However, these public examples do not establish the complete internal algorithm. We should not assume that every GPT Image 2.6 GIF request uses an identical sprite-sheet pipeline, that all frames are rendered in one neural-network pass, or that OpenAI has disclosed a particular temporal architecture. The sprite sheet is a concrete, visible way to understand the workflow.
3. The hard part is keeping the drawings connected
Suppose the cat’s head becomes larger halfway through the sequence. Or the rug changes color whenever the paw moves. The file would still be a valid GIF, but the animation would flicker.
Three constraints make the difference:
- Visual consistency. The character, setting, scale, and lighting should remain recognizable across frames.
- Motion continuity. Each pose should advance the same action, with changes small enough for the chosen playback speed.
- Loop continuity. The transition from the final pose back to the first should feel natural.
These are requirements for a successful result, rather than a claim about a particular hidden model component.
A practical starting point is one subject, one action, and a fixed camera. For the cat, ask it to raise a paw, wave once, and return to the resting pose. Asking for a camera orbit, a costume change, and a background transformation at the same time adds several more things that must remain coordinated.
Returning toward the starting pose helps close the loop. Exact duplicate first and last frames are not always necessary: holding the same pose twice can introduce a small pause at the join.
4. Generating a GIF through the API
The API can return a finished GIF. Your application does not have to receive a sprite sheet and crop it manually. OpenAI documents GIF output on the image generation endpoint, with the animation returned as Base64 data. Animated GIF output guide
Here is a minimal request. It requires an API key in OPENAI_API_KEY and GIF access for the selected model.
curl --fail-with-body https://api.openai.com/v1/images/generations \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-image-2.6-flare",
"prompt": "A small orange cat sits on a sage-green rug, raises one paw, waves once, and returns to its resting pose. Fixed camera, plain cream background, flat illustration, seamless loop.",
"output_format": "gif",
"frame_count": 9,
"frame_duration_ms": 200,
"size": "auto"
}' -o response.json
In this request, output_format selects GIF output, while frame_count and frame_duration_ms control the number of frames and their requested display time. size describes each finished frame; auto lets the service choose the dimensions. Image generation API reference
After a successful response, save the returned animation with this short Python snippet.
import base64
import json
from pathlib import Path
result = json.loads(Path("response.json").read_text())
Path("cat-wave.gif").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
The code above decodes the returned file bytes. Renaming the JSON response to .gif would not perform that decoding.
One launch detail needs care. As of November 5, 2026, the guide lists 2–64 frames, but the API reference lists 2–16 frames and requires GIF preview access. Start with a value such as nine and treat the service’s validation for your account as authoritative. The guide also applies a total request pixel budget, so supported frame counts depend on frame dimensions and the number of requested animations. GIF guide, API parameter limits
5. Frame count and playback speed are different controls
For equal frame delays, the intended duration of one cycle is easy to calculate:
Cycle duration = frame count × frame delay.
Nine frames displayed for 200 milliseconds each produce a nominal 1.8-second cycle. That is five frames per second.
Changing the delay changes playback speed. Changing the frame count changes how many distinct pictures are available to describe the movement.
| Frames | Delay per frame | Cycle duration | Playback rate |
|---|---|---|---|
| 9 | 200 ms | 1.8 seconds | 5 fps |
| 9 | 100 ms | 0.9 seconds | 10 fps |
| 16 | 100 ms | 1.6 seconds | 10 fps |
These are timing calculations, not measured model outputs. If you halve the delay without adding new poses, the same sequence plays twice as quickly. To make an action smoother while keeping its duration similar, you generally need more useful intermediate poses as well as a shorter delay.
6. Try the workflow in a browser
If you would rather start with a description than an API request, I built texttogif.com for this workflow. It uses the new GPT Image 2.6 models to turn text prompts into animated GIFs, with a browser interface for choosing the frame count and playback interval.
Enter a subject and a small action, select GIF, and open Advanced settings to adjust the animation. For a first experiment, try nine frames at 200 milliseconds per frame. The current interface supports 2–16 frames and displays the credit cost before you generate.
The preview shown here is the site’s existing example; the prompt on the left is ready for a new generation.
7. Where this approach fits
A short loop has a small storytelling budget. A blink, a nod, a waving mascot, or a gently moving icon can communicate its idea with a few poses. A long action sequence asks much more of every transition.
As a practical rule, match the tool to the motion you need:
| What you want to make | A useful starting point |
|---|---|
| A reaction, sticker, or simple mascot loop | A short GIF with one clear action |
| An animated icon or small product accent | A restrained loop with a stable composition |
| A scene with sustained action and camera movement | Evaluate a video generation workflow |
| A sequence with speech or music | Use a workflow that supports audio |
GPT Image 2.6’s model documentation lists image output and no audio or video modality. GIF support gives it an animation output without making it a general video-and-audio generator. Flare model documentation
There are two further limits to remember.
First, GIF output is currently supported by /v1/images/generations, while /v1/images/edits does not support it. Uploading an existing picture and animating it therefore requires more than adding output_format: "gif" to an image edit request. GIF endpoint support
Second, GIF uses indexed color. Each color table has at most 256 entries, although different images in the animation can use different local tables. Fine gradients may need color reduction or dithering, so flat illustrations and restrained palettes are sensible starting points. GIF color-table specification
The central idea is straightforward: generate a coherent set of visual moments, then give those moments an order and a rhythm. GIF encoding handles playback. The quality of the animation comes from how well the drawings carry the action from one moment to the next, including the jump back to the beginning.
Top comments (0)