GPT Image 2.5 ships through the API as two models: gpt-image-2.5-flare, the default tier at roughly half the latency of GPT Image 2, and gpt-image-2.5-sunburst, the highest-fidelity tier. They share one price list at 1K and 2K; at 4K Sunburst has its own, higher row, listed separately under the table below. What differs between the two providers is the shape of the bill: OpenAI charges by output image tokens, which climb steeply with the quality setting, while APIMODELS charges a fixed price per cell — resolution × quality, fifteen cells — that you can read off a table before you send the request.
OpenAI bills 2.5 at $30 per million output image tokens ($5 per million text input tokens, $8 for image input), and publishes no per-image example prices. To get comparable numbers we measured what every size and quality actually consumes on the genuine pipeline — 439 tokens for a 1024×1024 medium image, 3568 for 2048×2048 high, 3336 for 3840×2160 high — and multiplied by the list rate. That is the "OpenAI" column: a list-rate cost, marked approximate because your own prompts will land within a few tokens of ours. Because the token count tracks rendered detail rather than pixel count, the quality setting is what dominates that bill — at 3840×2160, max costs about 36 times as much as low for the same frame.
APIMODELS prices by resolution and quality — and, at 4K only, by model. 1K: $0.008 / $0.020 / $0.03 / $0.05 / $0.08; 2K: $0.020 / $0.025 / $0.04 / $0.08 / $0.15; 4K: $0.020 / $0.045 / $0.08 / $0.17 / $0.3 on Flare and $0.020 / $0.085 / $0.16 / $0.28 / $0.47 on Sunburst, for low / medium / high / xhigh / max. Flare renders at medium unless you pass quality; Sunburst renders at high by default — and since quality is a price axis, at 1K and 2K that default is the only reason a Sunburst call costs more than a Flare call; at 4K the Sunburst row itself is higher too. Reference images and transparent background add nothing, failed generations are not charged, and the cell is decided by the total pixel count of the image you actually receive (1.7MP or less is 1K, 1.7-4.6MP is 2K, above 4.6MP is 4K), not by its longest edge.
Two billing shapes means it is worth being precise about where the fixed price is lower. At high — the Sunburst default, and the cell most images that ship are rendered at — we are lower at 1K ($0.03 against about $0.053, 43% less) and much lower at 2K ($0.04 against about $0.107, 63% less). 2K medium is lower too ($0.025 against about $0.027). Above medium Flare is lower at 4K as well, including the top two cells: $0.08 against about $0.100 at high, $0.17 against about $0.178 at xhigh and $0.3 against about $0.40 at max. Sunburst has its own 4K row ($0.020 / $0.085 / $0.16 / $0.28 / $0.47), so for 4K work where unit price decides, Flare is the one to compare.
Price is only half of it, and for most people who land on this page it is not the half that decides. A fixed per-cell price is a bill you can quote before the call instead of after it, which matters when you are pricing a feature for your own customers. Beyond that: no OpenAI account and no organization verification, direct access from mainland China, 1K / 2K / 4K output that is a native render rather than an upscale (4K at the exact requested 3840×2160; 2K at 2720×1536 or a same-ratio 2048px long edge such as 2048×1152, the size OpenAI itself documents as 2K — see the docs), five quality tiers including xhigh and max, failed generations refunded automatically, and one key that also covers Gemini, Seedream, Kling and the rest of the catalogue on one balance. This page was written on launch day, 2026-09-09, and last re-checked against the OpenAI price list and our own production numbers on 2026-09-19.
The fifteen cells make more sense applied to real jobs than read as unit prices. Each row below is "what this batch costs on each side": ours is the fixed cell price times the count, the OpenAI column is the list-rate cost from measured tokens times the count. The 4K rows are priced on Flare; the Sunburst 4K row is listed under the price table above.
Now take one common e-commerce pipeline — 2,000 catalogue images at 1K medium, 500 hero images at 2K high and 50 print masters at 4K high on Flare per month — and it comes to $40 + $20 + $4 = $64 here against about $84.50 at list — about 24% less. Render those 50 masters on Sunburst instead and that line is $8 rather than $4, since Sunburst has its own 4K row. Price aside, the things in the next section matter just as much: a quotable cost, no charge for failures, no organization verification.
| Workload | Cell | APIMODELS | OpenAI list ≈ | Lower |
|---|---|---|---|---|
| 1,000 social carousels at a sharper size | 2K medium | $0.025 × 1,000 = $25 | ~$0.027 × 1,000 ≈ $27 | APIMODELS (−7%) |
| 300 product shots that ship | 1K high | $0.03 × 300 = $9 | ~$0.053 × 300 ≈ $15.90 | APIMODELS (−43%) |
| 500 hero / banner images (Sunburst default) | 2K high | $0.04 × 500 = $20 | ~$0.107 × 500 ≈ $53.50 | APIMODELS (−63%) |
| 50 print masters (Flare) | 4K high | $0.08 × 50 = $4 | ~$0.100 × 50 ≈ $5 | APIMODELS (−20%) |
| 30 large-format prints (Flare) | 4K xhigh | $0.17 × 30 = $5.10 | ~$0.178 × 30 ≈ $5.34 | APIMODELS (−4%) |
| 20 posters at the top tier (Flare) | 4K max | $0.3 × 20 = $6 | ~$0.40 × 20 = $8 | APIMODELS (−25%) |
One rate card — with Sunburst on its own 4K row — but each industry lands on different cells. The recommendations below come from our own 32 Flare / Sunburst pairs and the per-tier examples on the docs page, not from guesswork: systematic, exact work — charts, layouts, logos — is fine on Flare; material, fabric and print, the things people look at up close, are where Sunburst’s extra time lands.
Reference images and transparent backgrounds cost nothing extra in any cell; failed generations are not charged; large uploads go through https://api.apimodels.app/v1 at 100MB per request.
| Industry | Model + cell | Per image | Why |
|---|---|---|---|
| E-commerce catalogue and listings | Flare 1K medium; Sunburst 2K high for hero shots | $0.020 / $0.04 | Volume tiles need speed; hero shots need surface detail. Cut-outs via background=transparent are free. |
| Social and content teams (9:16) | Flare 1K medium; 1K low for drafts and A/B variants | $0.020 / $0.008 | Turnaround decides it; draft at low, finalise at medium. The caption in our 9:16 example rendered verbatim. |
| Print, packaging and signage | Sunburst 2K high; 4K high for large format | $0.04 / $0.16 | Fine print on our label test came out legible; brass engraving and wool weave held at 4K. |
| Games and app assets | Sunburst 1K high, transparent PNG | $0.03 | Sprite sheets and turnarounds need grid and outfit consistency — the pairs where the precision tier was steadier. |
| Agencies and SaaS builders | Flare by default, Sunburst per shot; reference-image edits on /v1/images/edits | $0.020–$0.04 | A fixed cell price you can quote to your own customers before the call; failures refunded; one key across the catalogue. |
Price per image — APIMODELS fixed cell price vs OpenAI list-rate cost (tokens measured 2026-09-09, list rate re-checked 2026-09-19; Flare and Sunburst share the 1K and 2K columns, the 4K column is Flare and the Sunburst 4K row follows the table)
1K (1024px) 2K (2048px) 4K (3840px), Flare
ours OpenAI ours OpenAI ours OpenAI
low $0.008 — $0.020 — $0.020 —
medium (Flare) $0.020 — $0.025 ~$0.027 $0.045 —
high (Sunburst) $0.03 ~$0.053 $0.04 ~$0.107 $0.08 ~$0.100
xhigh $0.05 (not measured) $0.08 (not measured) $0.17 ~$0.178
max $0.08 (not measured) $0.15 (not measured) $0.3 ~$0.400
Sunburst at 4K (own row): low $0.020 / medium $0.085 / high $0.16 /
xhigh $0.28 / max $0.47.
Read each cell across: the same request costs a fixed number here and
a token-dependent number at OpenAI. Quality is a price axis on both
sides; Sunburst defaults to high, Flare to medium.
Where the fixed price is lower (4K = Flare): every cell from high upward —
1K high (43% less), 2K high (63% less), 4K high (20% less), 4K xhigh
($0.17 against about $0.178) and 4K max ($0.3 against about $0.40);
2K medium is slightly lower too. A dash means the cell is not compared.
OpenAI column = $30 / 1M output image tokens x measured tokens per image
+ text-input tokens at $5 / 1M. xhigh and max were
measured at 3840x2160 only — the 1K and 2K cells are left blank rather
than extrapolated. Edits add image-input tokens at $8 / 1M on OpenAI
(about 1024 per reference at 1K); here reference images and
transparent background cost nothing extra.cURL
# Sync call, OpenAI shape: Flare at its default (medium) quality
curl https://api.apimodels.app/v1/images/generations \
-H "Authorization: Bearer $APIMODELS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-image-2.5-flare",
"prompt": "Product shot of a ceramic mug on linen, soft morning light",
"size": "1024x1024",
"background": "transparent",
"output_format": "png"
}'
# -> billed $0.020 (1K medium, the Flare default); pass "quality" to move cells: 1K low $0.008, 1K high $0.03Python
import requests, time
BASE = "https://api.apimodels.app/v1"
H = {"Authorization": "Bearer YOUR_API_KEY"}
# Task mode: Sunburst at 2K, explicit quality, then poll
task = requests.post(f"{BASE}/images/generations", headers=H, json={
"model": "gpt-image-2.5-sunburst",
"prompt": "Editorial portrait, mustard wool coat, rainy street, film grain",
"aspect_ratio": "3:2",
"resolution": "2K",
"quality": "high", # 2K high = $0.04; omit it and Sunburst still renders high. "medium" would bill $0.025
}).json()["data"]["taskId"]
while True:
r = requests.get(f"{BASE}/images/generations", headers=H,
params={"task_id": task}).json()["data"]
if r["state"] in ("completed", "failed"):
print(r)
break
time.sleep(3)It depends on the cell and the model. APIMODELS charges a fixed price per resolution × quality cell — $0.008 to $0.08 at 1K and $0.020 to $0.15 at 2K on both models; at 4K, $0.020 to $0.3 on Flare and $0.020 to $0.47 on Sunburst — while OpenAI bills output image tokens, which we convert to a per-image cost from measured token counts. At high, the Sunburst default, we are lower at 1K and 2K: $0.03 against about $0.053 at 1K and $0.04 against about $0.107 at 2K. 2K medium is lower too ($0.025 against about $0.027), and on the Flare 4K row we are lower from high upward ($0.08, $0.17 and $0.3 against about $0.100, $0.178 and $0.40). The OpenAI figures are list-rate costs computed from the tokens each image actually consumes, since there are no published per-image prices for 2.5.
OpenAI bills $30 per million output image tokens, so the per-image cost follows the tokens each image consumes, and that climbs steeply with quality. Measured on the genuine pipeline, a 1024×1024 image at high consumes about 1756 tokens — roughly $0.053 per image. 2048×2048 is about $0.027 at medium and $0.107 at high, and 3840×2160 about $0.100 at high. The two tiers above high climb much faster: at 3840×2160, xhigh costs about $0.178 and max about $0.400 — 36 times the low-quality price for the same frame. We measured xhigh and max at 4K only and have deliberately left the 1K and 2K cells blank rather than extrapolating them. Edits add image-input tokens at $8 per million, about 1024 per 1K reference image.
At 1K and 2K neither one is the more affordable model — they share one price grid there, so at the same quality they bill the identical number. At 4K Flare is the lower-priced of the two ($0.08 against $0.16 at high, $0.3 against $0.47 at max). Beyond that, what differs is the default and the wait. Flare defaults to medium ($0.020 at 1K, $0.025 at 2K) and is the right pick for social content, e-commerce variants and anything high-volume; Sunburst defaults to high ($0.03 at 1K, $0.04 at 2K), takes longer, and is tuned for premium commercial visuals and print. Either model accepts an explicit quality, so you can also stay on Flare and pass quality:"high" for the images that deserve it — at 1K and 2K you then pay exactly what Sunburst would bill for the same image.
Transparent backgrounds cost nothing extra: background=transparent returns a real alpha PNG at 1K, 2K or 4K at the same per-image price. Masks are a different answer — we no longer accept them at all, and a request carrying mask comes back as a 400. None of the upstream channels we tested treats a mask as a hard boundary: they repaint the protected region and still return 200, so we reject the parameter rather than ignore it. Name the object to change in the prompt — that is what keeps an edit local.
Two cases. First, if you need enterprise compliance paperwork that only a direct OpenAI or Azure contract provides — DPAs, SOC 2 chains. Second, if you already hold committed spend or negotiated volume pricing with OpenAI that you need to use. At high on 1K and 2K, at 2K medium, and from high upward on the Flare 4K row, the fixed cell is lower on price, and it wins on predictability everywhere — you can quote the cost of a feature before you ship it. The rest of the argument is the same as it ever was: no organization verification, direct access from mainland China, failed generations refunded, and one key across the whole catalogue.
Production medians over the last seven days (external traffic, successful calls, 2026-09-19): about 45s at 1K for both models (p90 around 65s), about 25s for Flare and 40s for Sunburst at 2K, about 35s for Sunburst and 50s for Flare at 4K; edits with a reference image 15-50s. All three tiers are native renders, not upscales — they passed a detail-energy check against known upscales. Sizes: 4K comes back exactly as requested — 3840×2160 (2160×3840 for 9:16). 2K comes back either at the requested 2720×1536 (1536×2720 for 9:16) or at the same aspect ratio with a 2048px long edge (about 2048×1152 at 16:9) — the size the official OpenAI documentation uses as its “2K” example; both bill as 2K.
