![GPT Image 2 API Pricing: Cost Comparison Across Platforms [2026]](/_next/image?url=https%3A%2F%2Fstatic.linkmodel.ai%2Fblog-cover%2Fcover-gpt-image-2-pricing.png&w=3840&q=75)
The One Number That Doesn't Exist
There is no single "GPT Image 2 price." OpenAI bills it per token, not per image, so the cost of one generation swings with resolution, quality tier, prompt length, and whether you pass reference images. Two teams running the same model can see a 30x difference in their monthly bill purely from configuration.
This article does the normalization work for you: the raw OpenAI rates, what they translate to per finished image, and how the main third-party gateways — including LinkModel — change the math. If you want the developer-features view instead (reasoning layer, editing, code), that lives in the GPT Image 2 API guide. This one is about money.
OpenAI's Direct Token Rates
GPT Image 2 launched on April 21, 2026 as OpenAI's first reasoning-based ("agentic") image model, and it uses the same token-based billing framework as the GPT text models. The published rates on OpenAI's API pricing page are:
| Token type | Rate (per 1M tokens) |
|---|---|
| Image output | $30.00 |
| Image input | $8.00 |
| Cached image input | $2.00 |
| Text input | $5.00 |
| Cached text input | $1.25 |
Two levers affect different billing paths. The Batch API publishes lower token rates in exchange for asynchronous processing, while cached text input is billed at $1.25 rather than $5.00 per million tokens. Do not assume discounts stack across every image-input and image-output category; model the exact categories shown in the current pricing table.
What That Is Per Image
Because output is token-metered, the practical per-image cost depends almost entirely on resolution and quality. Using OpenAI's own image-generation calculator as the reference, community and vendor breakdowns converge on roughly:
| Configuration | Approx. cost per image |
|---|---|
| 1024×1024, low quality | ~$0.006 |
| 1024×1024, medium quality | ~$0.05 |
| 1024×1024, high quality | ~$0.21 |
| 4K, high quality | ~$0.35–0.41 |
One trap worth flagging before you budget: editing is not free. When you pass a reference image for an edit, GPT Image 2 processes it at high input fidelity and you can't turn that off — every reference is billed at the high-fidelity input rate regardless of your output quality setting. A "generate, then edit four times" workflow can land 2–3x above the headline per-image number. If your pipeline is iterative, log a real week of calls before committing a quarterly budget.
Platform-by-Platform Comparison
GPT Image 2 is available directly from OpenAI and resold through several gateways, each with a different billing shape. Here's how the common routes line up. Third-party per-image figures are the providers' own published rates; verify them before you commit, since gateway pricing is provider-owned and changes independently of OpenAI.
| Route | Billing model | Indicative cost | Notes |
|---|---|---|---|
| OpenAI direct | Per token | $30.00/1M output | Full control; Batch API halves it |
| fal.ai | Per output image (provider-set) | Provider rate; ~$0.41/img at 4K high | Serverless; also offers per-GPU-second endpoints |
| OpenRouter | Per token (OpenAI-compatible) | Passes OpenAI-style token rates | Drop-in base-URL swap |
| Per-image gateways (e.g. Unifically) | Flat per resolution | ~$0.03 / $0.05 / $0.06 for 1K / 2K / 4K | Simplest to reason about |
| LinkModel | Displayed request/token rate | Check live model page | Compare the same size, quality, and input fidelity |
OpenAI's API exposes token-based billing and documented batch options. A gateway may expose the same model with a different price display or effective rate. Compare the live figures for every token category; a headline percentage cannot be applied safely to input, cached input, and output without confirmation.
Record the exact OpenAI and LinkModel lookup date beside the comparison. Use OpenAI's API pricing for the direct rate and the LinkModel GPT Image 2 page for the gateway rate.
When the Cheapest Route Isn't OpenAI at All
If your work doesn't need GPT Image 2's specific strengths — precise text rendering, agentic composition, high-fidelity editing — you're often paying a premium for capability you won't use. A medium-quality 1024px GPT Image 2 render (~$0.05) is roughly the same price as a flat-rate image on several open-model gateways that will do a perfectly good product thumbnail. For bulk, text-light generation, cheaper models on the same platform can be an order of magnitude less per image.
The reverse is also true: for logos, packaging with real copy, multilingual banners, or UI mockups where garbled text means a re-render, GPT Image 2's higher per-image cost is usually cheaper than the human time spent fixing a "free" bad output. Match the model to the job, not to the sticker price. The broader cross-category picture — text, image, and video together — is laid out in the AI API pricing comparison, and the pure cost-floor question is covered in the cheapest AI API guide.
How to Call It
LinkModel exposes GPT Image 2 through a single REST endpoint. You submit a job and poll for the result — the same async pattern used across every model on the platform, so switching models is a one-string change.
curl -X POST https://api.linkmodel.ai/api/v1/image-generation \
-H "Authorization: Bearer $LINKMODEL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-image-2",
"prompt": "A minimalist SaaS logo with the text \"NEXUS\" in clean Helvetica, deep navy gradient, subtle circuit pattern"
}'The response returns a task_id and the exact price for that request inside a standard envelope:
{
"code": 0,
"data": { "task_id": "cb61...ceff", "status": "processing", "price": 0.05 },
"msg": "success",
"request_id": "250b...4d35"
}Poll the query endpoint with your task_id to retrieve the finished image. Full parameters (resolution, aspect ratio, reference images) are in the API reference.
Budget for Accepted Outputs, Not Just Generated Images
The pricing calculator answers the cost of a request configuration. Production budgeting also needs the acceptance rate:
monthly image spend = requested images × attempts per accepted image × price per attempt
For 10,000 approved images, a $0.05 configuration with a 75% pass rate requires roughly 13,334 attempts and costs about $666.70. A $0.07 configuration with a 95% pass rate needs about 10,527 attempts and costs about $736.89. Review cost can reverse the choice again, so record it separately.
Inputs That Change the Bill
Check output size and quality, number and fidelity of reference images, edits versus new generations, and any batch discount. Do not compare a low-quality square generation with a high-quality 4K edit as if both were “one image.”
Pricing QA Checklist
- Date the official price source.
- Keep token rates and derived per-image estimates in separate columns.
- Show the formula behind every derived total.
- Recalculate after model or quality changes.
- Confirm whether failed, cancelled, or policy-rejected jobs are billed.
- Run a small invoice reconciliation before forecasting large volume.
Use platform comparisons only when every route exposes the same underlying model and output configuration. Otherwise, label it as a workflow comparison rather than a pure price comparison.
Bottom Line
- GPT Image 2 has no flat price — budget on tokens, and expect ~$0.05 medium / ~$0.21 high per 1024px image.
- Batch and cached-input pricing can reduce different parts of the bill; calculate them by token category.
- Reference-image edits bill at high fidelity you can't disable — model 2–3x for iterative work.
- Flat per-image gateways can simplify forecasting; compare LinkModel's live token categories with OpenAI direct for the exact workload.
Sign up for LinkModel to get a $1 starter credit — enough to run several GPT Image 2 generations and see your real per-image cost before you scale. Or test prompts first in the Playground.