OpenAI pushed its image stack forward on September 8, 2026, replacing the single GPT Image 2 model with two distinct options: GPT Image 2.5 Flare and GPT Image 2.5 Sunburst. The split matters more than a version bump suggests. Flare targets speed and everyday generation, while Sunburst trades latency for editing precision across multi-step workflows. If you shipped code against GPT Image 2 or the original GPT Image 1, several defaults changed, including new quality tiers, new resolution options, and a pricing structure that treats the two models differently.
This tutorial walks through setting up both models from a clean account, covers the Images API and the Responses API image generation tool, and ends with a working Flask microservice you can deploy today. Expect 13 concrete steps, six runnable code blocks, and a troubleshooting section built from the errors developers are actually hitting on OpenAI’s community forum right now.
What Is GPT Image 2.5? Flare vs Sunburst Explained
GPT Image 2.5 is not one model, it is a pair of them, each with its own dated snapshot: gpt-image-2.5-flare-2026-09-08 and gpt-image-2.5-sunburst-2026-09-08. Both accept text and image inputs and output images, and both plug into the same two entry points: the dedicated Images API and the image_generation tool inside the Responses API.
Flare is the model OpenAI recommends as the default for most applications. According to OpenAI’s own documentation, “GPT Image 2.5 Flare is the small model, optimized for speed, with image quality comparable to GPT Image 2,” a line pulled straight from the image-prompting guide. The company also claims Flare delivers higher-quality output than GPT Image 2 at roughly 50% lower latency, which matters if you are generating images inside a user-facing request rather than a background job.
Sunburst sits at the other end of the trade-off. It is described by OpenAI as the company’s most capable image generation and editing model, built for workflows where multi-step edits need to preserve fine detail, things like campaign creative that goes through several rounds of revision, or product photography that needs precise masking. The cost is generation time: Sunburst runs slower than Flare by design.
Both models support six quality settings (auto, low, medium, high, xhigh, and max), a jump from the four-tier system most developers remember from GPT Image 1. The xhigh and max tiers are new to the 2.5 generation and did not exist on GPT Image 2.
The naming convention itself is new too. Earlier GPT Image releases used a single numbered model per generation, so developers just picked the newest one and moved on. Splitting the 2.5 generation into two named variants forces an upfront decision: pick for speed, or pick for precision. That decision point is exactly what this tutorial is built to help you make correctly on the first attempt, instead of discovering the wrong default six weeks into production when a cost report lands on your desk.
Prerequisites: What You Need Before You Start
Gather these before writing a single line of code. Skipping any one of them is the fastest way to burn an hour on an error that has nothing to do with your prompt.
- An OpenAI platform account with billing enabled (platform.openai.com), not a ChatGPT Plus or Pro subscription, which does not grant API access on its own
- Python 3.9 or later, or Node.js 18 or later, depending on which SDK you use
- The official
openaiPython package, version 3.22.1 or later (verified current release on PyPI as of this writing), installed viapip install --upgrade openai - A terminal with
curlavailable, useful for quick tests without spinning up a script - Roughly $5 to $10 in prepaid API credit, enough to run every example in this guide several times over
- Basic familiarity with REST APIs and JSON, since both the Images API and the Responses API return structured JSON payloads
One detail trips up a lot of developers coming from ChatGPT’s image feature: using GPT Image 2.5 inside the ChatGPT app does not require any of this. This tutorial covers the API, the version you call from your own backend, not the consumer product.
Step 1-3: Create Your API Key and Enable Billing
Step 1. Log into platform.openai.com and open the API Keys page under your project settings. Click “Create new secret key,” name it something you will recognize later (like “gpt-image-2-5-tutorial”), and copy the value immediately. OpenAI only shows it once.
Step 2. Go to Billing and add a payment method if you have not already. Image generation is metered per request and will fail with an “insufficient_quota” error on a zero-balance account, even if the key itself is valid.
Step 3. Export the key as an environment variable rather than pasting it into your script. On macOS or Linux, run export OPENAI_API_KEY="sk-..." in your shell profile. On Windows, use setx OPENAI_API_KEY "sk-..." in PowerShell. Every official SDK reads this variable automatically, which keeps the key out of your source control history.
Step 4-6: Install the SDK and Send Your First Request
Step 4. Install the SDK for your language of choice.
# Python
pip install --upgrade openai
# Node.js
npm install openai@latestStep 5. Confirm the install picked up a version that actually knows about GPT Image 2.5. Older SDK builds will accept the model string but may reject newer parameters like xhigh quality, so run a quick version check before moving on.
python -c "import openai; print(openai.__version__)"Step 6. Send your first generation request through the dedicated Images API. This hits the POST /v1/images/generations endpoint directly.
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY from the environment
result = client.images.generate(
model="gpt-image-2.5-flare",
prompt="A weathered lighthouse on a rocky coast at dawn, soft orange light",
size="1536x1024",
quality="high",
)
image_base64 = result.data[0].b64_json
with open("lighthouse.png", "wb") as f:
import base64
f.write(base64.b64decode(image_base64))
print("Saved lighthouse.png")Run it, and within a few seconds you get a PNG saved locally. If you see an authentication error instead, double check that your shell session actually has OPENAI_API_KEY set, since a fresh terminal tab will not inherit a variable you exported in a different window.
Step 7-8: Choosing Quality, Size, and Aspect Ratio
Step 7. Pick a quality tier deliberately instead of leaving it on auto. OpenAI’s image generation guide states plainly that “the image generation tool allows you to generate images using a text prompt, and optionally image inputs,” but it does not pick a sensible cost tier for you, that choice is yours and it directly sets your bill.
| Quality Setting | Best Use Case | Relative Cost | Generation Speed |
|---|---|---|---|
| low | Thumbnails, rapid prototyping, A/B testing prompts | Lowest | Fastest |
| medium | Draft previews, internal mockups | Low | Fast |
| high | Customer-facing assets, blog headers | Moderate | Moderate |
| xhigh | Print-adjacent work, detailed product shots | High | Slower |
| max | Final creative deliverables, hero images | Highest | Slowest |
| auto | Letting OpenAI pick based on prompt complexity | Variable | Variable |
Step 8. Match your size parameter to the aspect ratio your layout actually needs. GPT Image 2.5 supports square, portrait, landscape, and ultra-wide formats, listed below with their rough aspect ratios.
1024x1024: 1:1, social avatars and icons1536x1024: 3:2, blog headers and article covers1024x1536: 2:3, mobile-first portrait layouts2048x2048: 1:1, higher-resolution square assets2048x1152: 16:9, widescreen hero banners3840x2160/2160x3840: 16:9 and 9:16 at near-4K resolution
Requesting an unsupported dimension, like 1920x1080, returns a 400 error rather than silently rounding to the nearest valid size. Stick to the published list.
Step 9: Generating Images Through the Responses API
If your application already uses the Responses API for chat or agent workflows, you do not need a separate code path for images. OpenAI’s own guide confirms this directly: “the API lets you generate and edit images from text prompts using gpt-image-2.5-sunburst and gpt-image-2.5-flare,” referring to the image_generation tool available inside responses.create() calls, as documented in the tools-image-generation guide.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.1",
input="Generate a minimalist icon of a mountain inside a circle, flat design, two colors",
tools=[{"type": "image_generation", "model": "gpt-image-2.5-flare"}],
)
for item in response.output:
if item.type == "image_generation_call":
import base64
with open("mountain_icon.png", "wb") as f:
f.write(base64.b64decode(item.result))
print("Icon saved")This pattern is worth adopting if your agent needs to decide, mid-conversation, whether to generate an image at all. OpenAI’s guidance is specific here too: “set the image_generation tool’s model to gpt-image-2.5-sunburst for precise editing, or gpt-image-2.5-flare for fast, high-quality image generation,” so the model choice happens inside the tool definition, not as a separate call.
Step 10: Editing Images and Using Reference Inputs
Editing runs through a different endpoint, POST /v1/images/edits, and this is where Sunburst earns its reputation. Upload an existing PNG, describe the change, and the model modifies the image in place rather than regenerating it from scratch.
from openai import OpenAI
client = OpenAI()
result = client.images.edit(
model="gpt-image-2.5-sunburst",
image=open("product_photo.png", "rb"),
prompt="Remove the background clutter and replace it with a seamless white studio backdrop",
quality="high",
)
import base64
with open("product_photo_edited.png", "wb") as f:
f.write(base64.b64decode(result.data[0].b64_json))For multi-step edits, chain calls by feeding the output of one edit into the next request as the new input image. This is the exact workflow OpenAI designed Sunburst around: “with the Image API, set model to gpt-image-2.5-sunburst or gpt-image-2.5-flare directly,” according to the image generation guide, and chaining is how you get iterative creative revisions without starting the prompt over each time.
How Many Reference Images Can You Send?
OpenAI has not published a confirmed maximum reference-image count specifically for GPT Image 2.5 edits at the time of this writing. If your workflow depends on a large batch of reference inputs, test incrementally in a staging environment and watch for a 400 response rather than assuming a number from a different model family.
Step 11: Transparent Backgrounds and Output Formats
Both Flare and Sunburst support a background parameter with two values: opaque and transparent. This matters for anything destined for compositing, stickers, product cutouts, UI icons, or layered design files where a flat white background becomes a problem the moment you drop the asset onto a colored canvas.
curl https://api.openai.com/v1/images/generations
-H "Authorization: Bearer $OPENAI_API_KEY"
-H "Content-Type: application/json"
-d '{
"model": "gpt-image-2.5-flare",
"prompt": "A small cartoon fox sticker, bold outline, flat colors",
"size": "1024x1024",
"background": "transparent",
"quality": "high"
}'Leave background unset and you will get an opaque result by default, which is an easy miss if you are porting code from an older integration that never had this parameter at all.
Step 12: Understanding GPT Image 2.5 Pricing
Pricing is where Flare and Sunburst actually diverge in ways that affect a production budget. According to OpenAI’s published pricing page, gpt-image-2.5-sunburst is billed at $8.00 per 1 million input tokens, $2.00 per 1 million cached input tokens, and $30.00 per 1 million output tokens. That cached-input rate is worth building around, since reusing the same reference image across several edit calls cuts that portion of the cost by 75%.
For a simpler mental model, OpenAI’s model reference page for the closely related chatgpt-image-latest baseline lists per-image pricing at 1024×1024 resolution of $0.009 at low quality, $0.034 at medium, and $0.133 at high. Treat these as a baseline sanity check rather than an exact Sunburst or Flare figure, since OpenAI prices image generation per token consumed rather than a flat per-image rate, and actual cost scales with resolution and quality tier. The full release details, including both dated snapshots, are documented in OpenAI’s API changelog and in the original community announcement thread, both worth bookmarking since OpenAI tends to update pricing and parameter details there before anywhere else.
| Cost Component | GPT Image 2.5 Sunburst | Reference Baseline (GPT Image 2-style, 1024×1024) |
|---|---|---|
| Input tokens | $8.00 per 1M | Included in per-image rate |
| Cached input tokens | $2.00 per 1M | Not separately listed |
| Output tokens | $30.00 per 1M | Included in per-image rate |
| Low quality, 1024×1024 | Billed per token | $0.009 per image |
| Medium quality, 1024×1024 | Billed per token | $0.034 per image |
| High quality, 1024×1024 | Billed per token | $0.133 per image |
Always check your usage dashboard after your first few dozen calls rather than estimating from a spreadsheet. Resolution, quality, and whether you are editing versus generating from scratch all move the final number.
Step 13: Build a Complete Working Project: A Flask Image Generation Microservice
Here is a small but complete service you can actually deploy. It exposes one endpoint, accepts a prompt plus optional quality and size, calls GPT Image 2.5 Flare by default, and falls back to Sunburst when the caller requests precision editing.
import base64
import os
from flask import Flask, request, jsonify, send_file
from io import BytesIO
from openai import OpenAI
app = Flask(__name__)
client = OpenAI()
ALLOWED_SIZES = {"1024x1024", "1536x1024", "1024x1536", "2048x2048", "2048x1152", "3840x2160", "2160x3840"}
ALLOWED_QUALITY = {"auto", "low", "medium", "high", "xhigh", "max"}
@app.route("/generate", methods=["POST"])
def generate():
data = request.get_json(force=True)
prompt = data.get("prompt")
if not prompt:
return jsonify({"error": "prompt is required"}), 400
size = data.get("size", "1024x1024")
quality = data.get("quality", "high")
precise = data.get("precise_edit", False)
if size not in ALLOWED_SIZES:
return jsonify({"error": f"size must be one of {sorted(ALLOWED_SIZES)}"}), 400
if quality not in ALLOWED_QUALITY:
return jsonify({"error": f"quality must be one of {sorted(ALLOWED_QUALITY)}"}), 400
model = "gpt-image-2.5-sunburst" if precise else "gpt-image-2.5-flare"
try:
result = client.images.generate(
model=model,
prompt=prompt,
size=size,
quality=quality,
background=data.get("background", "opaque"),
)
except Exception as exc:
return jsonify({"error": str(exc)}), 502
image_bytes = base64.b64decode(result.data[0].b64_json)
return send_file(BytesIO(image_bytes), mimetype="image/png")
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000)Test it with a single curl call once it is running locally.
curl -X POST http://localhost:5000/generate
-H "Content-Type: application/json"
-d '{"prompt": "A ceramic mug on a wooden table, morning light", "quality": "high", "size": "1024x1024"}'
--output mug.pngDeploy it behind a reverse proxy with a request timeout of at least 30 seconds, since max quality generations on Sunburst take noticeably longer than a typical API call and a tight timeout will kill valid requests before they finish.
Testing and Validating Your Integration Before Launch
A tutorial example running once on your laptop is not the same as a service holding up under real traffic. Before pointing production users at the Flask microservice above, run through a short validation pass.
Start with a load test using a tool like hey or locust at a traffic level roughly matching your expected peak, then watch for two things: how quickly your 429 responses climb, and whether your timeout setting actually survives a max quality Sunburst call under concurrent load. A service that works fine at one request at a time can still fall over once five requests queue up against the same rate limit tier.
Next, build a small regression set of 10 to 15 prompts that represent your actual use case, run them against both Flare and Sunburst at your chosen quality tier, and save the outputs. Every time OpenAI ships a new dated snapshot, rerun that same regression set and compare the results side by side. This catches silent quality drift before your users do, and it gives you a documented baseline to point to if a teammate asks why a particular model and quality combination was chosen in the first place.
Finally, test your error handling paths deliberately. Send a request with an invalid size string, an empty prompt, and a prompt designed to trip content moderation, and confirm your application surfaces a clean message in each case instead of crashing or returning a raw stack trace to the end user.
Sunburst vs Flare: Which Model Should You Actually Use?
The honest answer depends on where the image sits in your product. Default to Flare, and reach for Sunburst only when you have a specific reason.
| Factor | GPT Image 2.5 Flare | GPT Image 2.5 Sunburst |
|---|---|---|
| Primary strength | Speed, everyday generation | Editing precision, multi-step revisions |
| Latency vs GPT Image 2 | About 50% lower | Longer generation time by design |
| Recommended for | Social content, product listings, prototyping, high-volume generation | Campaign creative, final production assets, detailed edits |
| Output token cost | Lower than Sunburst | $30.00 per 1M output tokens |
| Default choice in OpenAI’s docs | Yes, for most applications | No, opt-in for precision work |
Teams running high volumes of product imagery, think e-commerce catalogs or social media automation, should start with Flare and only escalate specific assets to Sunburst after a human flags them for revision. Running everything through Sunburst by default inflates both your latency budget and your bill without a corresponding quality gain for simple, single-pass generations.
If you need a fully open-weight alternative you can self-host instead of calling an API, our Qwen-Image-2.1 self-hosting guide covers Alibaba’s 7-billion-parameter competitor, which ships with public weights and native transparency support of its own.
5 Common Pitfalls When Building With GPT Image 2.5
1. Treating Flare and Sunburst as interchangeable for cost estimates. Sunburst’s $30.00 per-million output token rate is not the same as Flare’s, and budgeting both at one flat number will throw off your forecast the moment usage scales.
2. Reusing GPT Image 1 or GPT Image 2 size strings without checking the new list. The 2.5 generation adds near-4K options like 3840x2160 that did not exist before, and an old hardcoded size constant can quietly cap your output resolution.
3. Leaving quality on auto in production. Auto is convenient for a demo, but it makes your per-request cost unpredictable, which is a problem the moment finance asks for a monthly image generation forecast.
4. Storing raw base64 payloads in application memory at scale. A single max quality image at near-4K resolution produces a large base64 string, and holding dozens of these in memory simultaneously during a traffic spike is a quick way to trigger an out-of-memory crash.
5. Forgetting the background parameter when building composited assets. Omitting background: transparent on sticker or icon generation produces an opaque result that then needs a separate background-removal step, which defeats the point of generating a transparent asset in the first place.
6. Assuming Sunburst always produces better results. For a single, straightforward text-to-image generation with no editing involved, Flare matches Sunburst on quality in most cases while finishing faster, so routing everything through the slower model adds latency without adding value.
Troubleshooting: 8 Common GPT Image 2.5 API Errors
- 401 Unauthorized: your API key is missing, expired, or belongs to a different project than the one with billing enabled. Regenerate the key and re-export the environment variable in a fresh terminal session.
- 429 Too Many Requests: you have hit your account’s rate limit tier. Add exponential backoff with a base delay of at least one second and retry, rather than hammering the endpoint in a tight loop.
- 400 Bad Request: invalid size: you passed a dimension string that is not in the published size list. Copy the exact strings from Step 8 rather than typing your own.
- insufficient_quota: your account has no prepaid credit or a payment method issue. Check Billing, not the API key itself, since the key will look perfectly valid.
- Content policy rejection with no image returned: your prompt tripped the safety system. Rephrase to remove ambiguous references to real people, violence, or anything that could read as impersonation.
- Edit request ignores the reference image: confirm the file you uploaded is actually a supported format (PNG is safest) and under the documented file-size ceiling, since a silently rejected upload can look like the model just ignored your instructions.
- Request times out before completion: this happens most often with
maxquality on Sunburst. Increase your HTTP client and reverse-proxy timeout to at least 30 seconds for that quality tier specifically. - SDK rejects the “xhigh” or “max” quality value: you are running an outdated SDK build. Run
pip install --upgrade openaiornpm install openai@latestand confirm the version string matches a release from September 2026 or later.
Advanced Tips: Rate Limits, Caching, and Cost Control
Rate limits scale with your account’s usage tier, and OpenAI has not published a confirmed per-minute figure specifically for GPT Image 2.5 Flare or Sunburst as of this writing, so check your account dashboard directly rather than relying on figures published for older models. Build your retry logic around the Retry-After response header when present instead of a fixed guess.
Cached input tokens on Sunburst cost $2.00 per million against a standard $8.00 per million, a 75% discount. If your application repeatedly edits the same base image, for example running five sequential revisions on one product photo, structure your calls so the reference image stays identical across the chain rather than re-uploading a freshly encoded copy each time, which can prevent the cache from matching.
For cost control at scale, route the bulk of your traffic through Flare at medium or high quality, and reserve Sunburst at xhigh or max for assets a human has explicitly flagged as final. Log every request’s model, quality, and size to a simple table so you can audit spend by category rather than discovering a surprise bill at the end of the month.
If your product already calls other OpenAI endpoints, pair this setup with our OpenAI Embeddings API setup guide for search-adjacent features, or see our GPT-6.1 Sol API setup walkthrough if you are wiring image generation into a broader agent pipeline. Teams comparing providers before committing should also look at our Grok 4.7 API setup guide and our Veo 3.1 API setup guide for video generation, since many teams end up running image and video models side by side. For a direct look at a rival image model, our Hy Image 3.5 API setup guide covers a lower-cost per-image alternative worth benchmarking against Flare.
Sample Output and What a Successful Response Looks Like
A successful call to images.generate() returns a JSON object with a data array. Here is a trimmed example of the shape you should expect, with the base64 payload shortened for readability.
{
"created": 1790870400,
"data": [
{
"b64_json": "iVBORw0KGgoAAAANSUhEUgAA...(truncated)...",
"revised_prompt": "A weathered lighthouse on a rocky coast at dawn, soft orange light, photorealistic"
}
],
"usage": {
"input_tokens": 42,
"output_tokens": 1710,
"total_tokens": 1752
}
}Note the usage block. This is what you should be logging for cost tracking, since it reflects the actual token consumption OpenAI bills against, not an estimate based on quality tier alone.
Comparing GPT Image 2.5 to Other Current Image Models
GPT Image 2.5 arrives into a crowded field. Alibaba’s Qwen-Image-2.1, released just weeks earlier on September 20, 2026, is a 7-billion-parameter open-weight diffusion transformer that supports editing from up to 10 reference images and ships with public weights on Hugging Face and ModelScope, though commercial use requires a separate license from Qwen. The practical difference for most teams comes down to control versus convenience: Qwen-Image-2.1 can run on your own hardware with no per-call fee once deployed, while GPT Image 2.5 trades that infrastructure burden for a managed endpoint billed per token.
Neither approach is universally correct. A startup generating a handful of marketing images per day has little reason to manage GPU infrastructure for a self-hosted model. A company generating hundreds of thousands of product images per month may find the economics flip the other way once output token costs accumulate. Run both on a representative sample of your actual prompts before committing to one.
OpenAI’s own model reference page for Flare is also worth reading end to end before you lock in a model choice, since OpenAI updates these pages with parameter changes faster than third-party tutorials can track. The same applies to Sunburst’s equivalent page. Checking both directly takes five minutes and can save you from building against a parameter default that changed after this article was published.
Security and Content Policy Considerations
OpenAI enforces automated content moderation on every image generation and edit request, rejecting prompts that violate its usage policies before an image is ever returned. The exact parameter names and threshold behavior for GPT Image 2.5 specifically were not published in verifiable form at the time of this writing, so build your application to handle a rejection response gracefully rather than assuming every request will succeed.
If your application lets end users submit prompts directly, add your own pre-filter layer in front of the API call. This catches obvious policy violations before you spend a token on a request that was going to fail anyway, and it gives you a chance to show a user-friendly error message instead of surfacing a raw API error string.
Migrating From GPT Image 2 or GPT Image 1 to 2.5
Most existing integrations do not need a rewrite. The model string is the main thing that changes: swap gpt-image-2 or gpt-image-1 for gpt-image-2.5-flare, run your existing test suite against it, and check the output against three things before shipping the switch to production.
First, audit every hardcoded size string in your codebase. GPT Image 1 shipped with a narrower set of dimensions, and code that validates against that old list will reject the new near-4K options this tutorial covers in Step 8, even though the API itself would happily accept them. Second, check any quality constant you have pinned to "high" as a ceiling. The new xhigh and max tiers sit above it, and a hardcoded validator that only allows four values will silently block them. Third, if you built cost estimates into your billing dashboard using GPT Image 1 or GPT Image 2 per-image rates, treat those as stale. Sunburst in particular bills differently from the flat rates teams got used to, so recalculate your monthly projection using the token-based figures in Step 12 rather than copying forward an old spreadsheet formula.
Run a side-by-side comparison for at least a week before fully cutting over. Generate the same batch of prompts through your old model and through Flare, compare the outputs manually, and only retire the old code path once you are confident the new default matches or beats what you had running in production.
Using GPT Image 2.5 From Node.js
Python is not the only option here. If your backend runs on Node, the official SDK exposes the same endpoints with a near-identical method signature. Install the current package and request an image the same way you would from a browser-facing API route.
import OpenAI from "openai";
import fs from "fs";
const client = new OpenAI(); // reads OPENAI_API_KEY from the environment
async function generateImage() {
const result = await client.images.generate({
model: "gpt-image-2.5-flare",
prompt: "A cozy bookstore interior, warm lighting, shot on film",
size: "1536x1024",
quality: "high",
});
const imageBuffer = Buffer.from(result.data[0].b64_json, "base64");
fs.writeFileSync("bookstore.png", imageBuffer);
console.log("Saved bookstore.png");
}
generateImage();Wrap this in an Express route handler and you have a drop-in image generation endpoint for a Node backend without touching Python at all. The same quality, size, and background parameters from the Python examples apply unchanged.
Real-World Use Cases: Where Each Model Actually Fits
Abstract comparisons only go so far. Here is how the Flare and Sunburst split plays out across common product scenarios.
E-commerce product listings. A marketplace generating thousands of lifestyle shots per day for seller listings should run Flare at medium or high quality by default. Volume matters more than per-image perfection here, and Flare’s lower latency keeps the listing pipeline from backing up during a bulk upload.
Marketing campaign creative. An agency producing a hero image for a paid campaign, one that will get revised five or six times before a client signs off, benefits from Sunburst’s editing precision. The slower generation time is a non-issue when a human is reviewing each revision anyway.
In-app avatar and icon generation. A consumer app letting users generate a custom profile icon needs speed above all else, since users will not wait more than a few seconds for a result inside an onboarding flow. Flare at low or medium quality with a transparent background fits this case well.
Print and packaging mockups. Teams generating near-final packaging art that heads to a printer should use Sunburst at xhigh or max quality, where the higher per-token cost is small relative to the cost of a print run going out with a flawed design.
Frequently Asked Questions
Is GPT Image 2.5 the same as the image generator inside ChatGPT?
They share the same underlying models, but accessing GPT Image 2.5 Flare or Sunburst programmatically requires a platform.openai.com API key and billing setup, separate from a ChatGPT Plus or Pro subscription.
Which model should I use for most applications, Flare or Sunburst?
Start with Flare. OpenAI positions it as the default for fast, high-quality everyday generation, and it costs less per output token than Sunburst. Switch to Sunburst only for workflows that need precise, multi-step editing.
Can I generate transparent PNG images with GPT Image 2.5?
Yes. Set the background parameter to transparent on either model. Leaving it unset defaults to an opaque background.
What is the maximum resolution GPT Image 2.5 supports?
The published size list tops out at 3840x2160 and its portrait equivalent 2160x3840, both near 4K resolution, alongside smaller square and widescreen options.
How much does GPT Image 2.5 cost per image?
Pricing is token-based rather than a flat per-image rate. Sunburst is billed at $8.00 per million input tokens, $2.00 per million cached input tokens, and $30.00 per million output tokens, according to OpenAI’s published pricing page. A comparable GPT Image 2-style baseline at 1024×1024 runs roughly $0.009 at low quality up to $0.133 at high quality per image.
Do I need a special SDK version to use GPT Image 2.5?
You need a reasonably current build of the official SDK. The Python package was at version 3.22.1 at the time of this writing. Run pip install --upgrade openai before testing newer parameters like xhigh or max quality.
Can GPT Image 2.5 edit an existing image instead of generating a new one?
Yes, through the separate /v1/images/edits endpoint. Upload the source image and describe the change in your prompt. Sunburst is the better choice here for precision edits.
What happens if my prompt gets rejected by content moderation?
The API returns an error response with no image data rather than a partially generated result. Build your application to catch this case and show a clear message to the end user instead of surfacing a raw error.