With image generation, you are not only waiting for the first image. You change the composition, correct product colors, and adjust facial expressions. When that back-and-forth becomes shorter, the way you work also changes.

Images 2.6, announced by OpenAI on November 4, is an update that expands not only generation speed, but also editing control and output formats. The API offers GPT-Image-2.6 Flare / Sunburst.

1. This update in one sentence

It is an update that enables faster generation, allows you to fix the areas that need fixing, and lets you receive output in a format suited to the intended use.

According to the official blog, image generation is now 50% faster than before. Flare can generate an image in as little as approximately 6 seconds with quality=low. GIF support, image markup in the API, SVG output, and a new complexity setting have also been added.

The “4 billion images per week” mentioned in the blog refers to the total number of images generated across ChatGPT, Codex, and the API. It is not a usage figure for version 2.6 alone or an indication of its popularity in Japan.

2. Which should you choose, Flare or Sunburst?

Model Features described by the official documentation General guidance on when to choose it Flare Fast generation with the low-quality setting. Improved layouts for posters and product images Rough drafts and comparing multiple options Sunburst The medium / high settings prioritize high image quality and consistency during editing Production work that preserves the details of people, products, and brands

The right-hand column is a suggested way to differentiate usage based on the official features; it is not based on comparative image-quality testing. The API guide also states that there are limitations involving text placement, character consistency, and precise composition. You need to check elements that must not change, such as product names and faces.

3. quality and complexity are separate settings

• quality: The detail and fidelity of the rendering
• complexity: How much planning is undertaken before rendering to meet the request

complexity is low / medium / high. The API guide states that, when omitted, it is high for both models. Higher settings can help with complex layouts and relationships between objects, but may also increase wait times or the likelihood of unintended changes.

The official blog gives the following recommendations.

| Task | complexity | quality | |---|---|---| | Many editing tasks | low | Match the desired level of quality | | Situations with many elements and constraints | Compare medium / high | Match the desired level of quality |

This can be read as follows: for a “background-only change,” consider low first. For “placing multiple products and descriptions,” compare the planning-side settings as well. High-quality partial edits and new generations of complex compositions do not need to use the same setting.

There is no separate charge for adjusting complexity itself. However, this does not mean that the entire generation is free.

4. GIF: The Official Six-Frame Example and Direct API Output

What the official prompt specifies

The blog’s OpenArt example gives instructions to draw an office worker’s expressions and movements as a single sprite sheet with 3 columns × 2 rows, for a total of 6 frames. In addition to the subject, it specifies the following.

-
• Reading order from left to right and top to bottom, and identical frame dimensions
-
• A fixed camera and the same person, clothing, and background
-
• Gradually progressing motion and a connection from the sixth frame back to the first
-
• Do not draw borders, padding between frames, text, or labels

This is a template that renders the structure in Japanese. It is not a word-for-word translation of the official wording, but an unverified adaptation.

The API can return a completed GIF

The example and the API specification need to be considered separately. The guide explains that specifying output_format: "gif" will return a completed animation. This does not mean that manually splitting the frames is required.

Both the generation and editing endpoints support it. frame_count ranges from 2 to 16 (default: 9), and frame_duration_ms ranges from 20 to 2000 milliseconds (default: 200, rounded to 10-millisecond increments). size refers to the dimensions of each frame.

The following is an example that follows the format of the official documentation (the hands-on testing in this article was conducted using an equivalent Image API call; this is not a record of rerunning that exact curl one-liner). You need to set OPENAI_API_KEY and have curl, jq, and base64 available.To output a GIF directly, specify the action in the prompt rather than a frame-by-frame breakdown.

Frame counts and dimensions are subject to the model’s limits and the request’s overall pixel budget. GIF output does not support streaming, intermediate images, or optional output compression. We have not verified that this example returns in 6 seconds, either.

5. markup and SVG connect the stages before and after creation

In the official

markup example, a vase circled in red is changed to blue. Send the original image and a separate annotation layer to POST /v1/images/edits.

The annotations are not baked into the original image; make them into a transparent PNG of the same dimensions and send them via markup. The target is the first input image, and it cannot be used together with a mask. In addition to “what to change,” this example specifies “what to preserve” and “remove the circle from the final image.” It is useful for edits whose locations are difficult to convey through text alone.

SVG is generated by specifying output_format: "svg" and n: 1 with the generation endpoint. The editing endpoint does not support SVG output.

The API creates a reference image and generates an SVG based on it. The result is a static vector, and scripts, external resources, and embedded raster images are not supported.It seems well suited to creative work where you want to adjust the paths and colors of icons or illustrations afterward.

6. For a Japanese team, where should you start?

What follows are use-case ideas. Quality in Japanese and approval by each service have not yet been confirmed.

• Mascot: Consider a short GIF of the mascot waving while checking its face and color scheme
• Sticker-style assets: Create variations in expression. Check the destination platform’s specifications separately
• EC product images: Compare layout options in Flare, and also compare Sunburst for edits where preserving fine details is important

If you include Japanese product names or prices, you would ideally include proofreading in the workflow. The official guide also notes limitations on text legibility and placement.

7. Pricing and availability

In the Standard column of the official price list, both models have the following unit prices. These are prices in US dollars per 1 million tokens, rather than per image.Per 1 million tokens, not per image

Target Unit price Text input $5 Image input $8 Image output $30

The number of tokens consumed varies by model and quality settings, so the cost per image is not fixed. The guide explicitly states that, for SVG, token charges apply to the model used to write the SVG in addition to generating the reference image.

Measurement: token usage with OpenAI’s official API

On November 8, 2026 (PST), GPT Image 2.5 / 2.6 (Flare / Sunburst) was called via OpenAI’s official POST /v1/images/generations endpoint using the same prompt. The model IDs, such as gpt-image-2.5-flare, are as specified in the official documentation. The sample is small, so please read this as a reference record.The sample is small, so please read this as a reference record.

• Still images: size=1024x1024, n=1, PNG, quality=low / medium. complexity omitted (official default: high).
• The response’s quality / size matched the specified values (e.g., low→low, 1024x1024→1024x1024).
• For usage, the usage in the response (input_tokens_details / output_tokens_details) was used.

Fixed prompt:

Still images (1024×1024 PNG): differences between 2.5 and 2.6

Text input is approximately 55 tokens. The calculated amount is based arithmetically on the official rates (text input $5/M + image output $30/M) and is not a substitute for itemized billing.Since the $/M in the rate table is the same for 2.5 and 2.6,the difference in cost per image under the same conditions comes primarily from the difference in image output tokens consumed.

Specified model quality Run count Image output tokens Calculated amount at official rates / run Actual dimensions 2.5-flare low 2 196 $0.006155 1024×1024 2.5-flare medium 1 439 $0.013445 1024×1024 2.5-sunburst low 1 196 $0.006155 1024×1024 2.5-sunburst medium 1 439 $0.013445 1024×1024 2.6-flare low 2 824 $0.024995 1024×1024 2.6-flare medium 1 1449 $0.043745 1024×1024 2.6-sunburst low 1 824 $0.024995 1024×1024 2.6-sunburst medium 1 1449 $0.043745 1024×1024

Under the same conditions (1024×1024 / low), 2.5 used 196 image output tokens, while 2.6 used 824. For medium, 2.5 used 439 and 2.6 used 1449. These are only a small number of samples and do not replace the pricing table for all prompt sizes.

GIF multipliers/frame count and measured limits

• 1024×1024 GIF: Rejected with an error stating that the long side of the frame sheet exceeds 3840 (e.g., 4096x2048).
• 512×512 GIF: Both 4-frame and 9-frame outputs succeeded. The actual dimensions remained 512×512. Output tokens were 555 for 4 frames and 1172 for 9 frames.
• Multiplier relative to a same-size PNG: 512 PNGs were rejected for being below the minimum pixel budget, so832×832 was used to make the GIF and PNG sizes consistent. 4-frame GIF / PNG ≈ 1.40 (1017 / 727), 9-frame GIF / PNG ≈ 3.05 (2214 / 727). The per-frame averages for 4 frames and 9 frames are close,and generally proportional to the number of frames (there may be tiered sheet billing).
• frame_count: 2 and 16 succeeded, while 17 was rejected (2–16, as specified officially).
• frame_duration_ms=2000: Succeeded with 4 frames.
• 2.5 GIF: Rejected with the error "GIF output is not enabled for the model 'gpt-image-2.5-flare'". It is safer to treat GIF output as a feature available only on 2.6.

The official blog states that availability covers all ChatGPT and Codex subscription tiers, desktop, mobile, and web, worldwide. Both models are available through the API. It does not state that they are “limited to paid plans.”

The system card also explains safeguards for motion unique to GIFs and notes that it cannot detect every violation. Before publication, it would be good to check the entire loop, not just the still image.

The four points to distinguish are model, rendering quality, degree of planning, and output format. Rather than selecting all the higher settings, determine the settings based on the scope of revisions and the desired final result. I believe that is the key point when reading this update.

8. Being able to invoke it

Although the subject of the article is OpenAI’s 2.6 update itself, to briefly touch on the implementation, GPT-Image-2.6 (Flare / Sunburst) can also be invoked from Flatkey. You can use it when trying out still-image generation with 2.6.

References

• Introducing Images 2.6 — OpenAI
• Image generation — API guide
• API Pricing — Image generation
• ChatGPT Images 2.6 System Card