As of May 6, 2026, the useful GPT Image 2 cost-per-image answer starts with official output examples: a 1024x1024 image is $0.006 at low quality, $0.053 at medium quality, or $0.211 at high quality. A 1024x1536 or 1536x1024 output is $0.005, $0.041, or $0.165 at the same quality tiers. These are output examples, not guaranteed all-in invoices: a real API bill can also include text input, image input for edits or reference images, partial images, retries, Batch routing, or a separate provider contract.
Quick Answer: Official Output Examples
The safest way to budget one GPT Image 2 image is to start with OpenAI's own image-generation cost examples, then add the parts that your request actually uses. The examples below come from OpenAI's image generation guide and pricing pages, not from a third-party provider table.
| Output size | Low quality | Medium quality | High quality | What the row means |
|---|---|---|---|---|
| 1024x1024 | $0.006 | $0.053 | $0.211 | Official output example for a square image |
| 1024x1536 | $0.005 | $0.041 | $0.165 | Official output example for portrait |
| 1536x1024 | $0.005 | $0.041 | $0.165 | Official output example for landscape |
Those numbers are useful because they answer the reader's real question in dollars per image. They are also incomplete by design. OpenAI's own formula treats final cost as a combination of input text, image input when you upload or edit images, and image output. If you request partial images, upload references, retry failed prompts, or send the job through Batch, the final bill changes even when the visible output looks like "one image."
What The Official Price Rows Actually Charge
GPT Image 2 is listed on OpenAI's official pricing page with image-token rows and text-token rows. For image billing, the visible rows are image input at $8.00 per 1M tokens, cached image input at $2.00 per 1M tokens, and image output at $30.00 per 1M tokens. For text input to the model, the pricing page lists $5.00 per 1M input tokens and $1.25 per 1M cached input tokens. These rows are the source behind the calculator examples, but they are not the easiest first screen for a person asking "what does one image cost?"
The cost guide turns those token rows into example outputs by size and quality. That is why a useful budget starts with the practical examples first and keeps the token rows as the explanation underneath. A developer estimating a first prototype needs a number they can reason with; a developer building a production cost model needs the token rows and the formula.
OpenAI Batch is a separate official cost lever. The pricing page lists lower Batch rows for eligible asynchronous workloads, including image input at $4.00 per 1M tokens, cached image input at $1.00 per 1M tokens, and image output at $15.00 per 1M tokens. Text input Batch rows are also lower. Batch is useful when your workload can wait for asynchronous processing; it is not a magic discount for an interactive user who needs the image back immediately.
The Real Formula For One API Bill
The real bill for a GPT Image 2 job is better described as a small formula:
| Component | When it appears | How to think about it |
|---|---|---|
| Text input | Every prompt has text instructions | Usually small compared with image output, but not zero |
| Image input | You upload reference images, masks, or edit inputs | Can matter in edit-heavy workflows |
| Image output | The generated image itself | This is what the official per-image examples mainly represent |
| Partial images | You request partial output previews | OpenAI notes partial images add output-token cost |
| Retries | You regenerate because the first output missed the mark | Each successful additional output is another workload |
| Batch | The job can run asynchronously | Can reduce official cost, but changes latency and workflow |
The important budgeting move is to keep "output example" and "invoice" separate. If you ask for one clean 1024x1024 high-quality generation, $0.211 is the official output example to start from. If you also upload several images, ask for edits, request partial images, and retry three times, the job is no longer one simple output example.
Why A Larger Non-Square Image Can Cost Less
The official examples surprise many readers because 1024x1536 and 1536x1024 are larger in pixel area than 1024x1024, yet their example costs are lower at the same quality tier. That is not a typo to "fix" in your spreadsheet. It means the public calculator examples are not a simple pixel-count formula you can extrapolate from.
For budgeting, use the published examples for the common sizes OpenAI exposes instead of inventing a linear rule. If your application generates only one of the listed sizes, the table is enough for a first estimate. If your application mixes sizes, qualities, edit inputs, and retries, build a small internal calculator that labels each assumption rather than multiplying pixels by a guessed rate.
This distinction matters for teams comparing square thumbnails with portrait social assets. A product manager might assume that portrait is always more expensive because it has more pixels. The official examples show the opposite for these common configurations, so the correct question is not "which image has more pixels?" but "which official size and quality setting is my workflow actually using?"
Separate OpenAI Direct, Batch, Providers, And ChatGPT Plans
Most price confusion comes from mixing four different contract owners:
| Route | Price owner | Good for | Do not confuse it with |
|---|---|---|---|
| OpenAI direct API | OpenAI official API pricing | First-party billing, official model identity, direct API accountability | A gateway's flat-call contract |
| OpenAI Batch | OpenAI official Batch pricing | Async jobs that can tolerate delayed completion | Interactive image generation |
| Provider or gateway route | The provider's own contract | Access routing, local payment, simplified gateway workflows, or provider-specific pricing | Official OpenAI direct pricing |
| ChatGPT plan access | ChatGPT subscription terms | Consumer app usage inside ChatGPT | API billing for gpt-image-2 |
For an official cost estimate, provider prices should stay secondary unless you verify that provider's current contract in the same buying decision. If your next question is "which cheap provider route should I try?", use the separate GPT Image 2 API cheap route guide. Keep provider selection separate from the official cost calculator so the billing owner remains clear.
The same boundary applies to ChatGPT. A ChatGPT plan can include image-generation access inside the consumer product, but that does not make the API free or convert subscription usage into API billing. OpenAI's GPT Image 2 model page identifies gpt-image-2 as an API model and shows the official route boundaries; use that model page for API identity and the pricing page for API billing.
Workload Scenarios: Which Number Should You Budget?
Use the table below as a budgeting shortcut before you build a full calculator.
| Workload | First estimate | What can change the bill | Practical rule |
|---|---|---|---|
| Draft tests | Low or medium official output example | Retries and prompt iteration | Count every accepted output, not only the final image |
| Normal production | Medium official output example for the actual size | Volume, quality tier, and occasional retries | Track quality and size in logs so cost analysis is not guesswork |
| High-quality output | High official output example | Reference images, edits, and rejected attempts | High quality should have its own budget line |
| Edit-heavy workflow | Output example plus image input | Uploaded images, masks, reference images, and partials | Estimate edit jobs separately from text-only generation |
| Async batch jobs | Batch rows if eligible | Delayed completion, job grouping, and retry policy | Use Batch only when latency tradeoffs are acceptable |
The scenario table is intentionally not a provider comparison. A provider route may quote a simpler unit, such as a flat call price, but that price belongs to that provider's gateway contract. It can be a useful buying option, but it should not overwrite the official OpenAI calculator when the reader is trying to understand GPT Image 2's direct API cost.
Build A Small Calculator Before Production
A production calculator for GPT Image 2 does not need to be complicated. It needs to preserve the variables that actually change the bill.
Start with these fields:
| Field | Example values | Why it matters |
|---|---|---|
model | gpt-image-2 | Keeps the cost model tied to the right product |
size | 1024x1024, 1024x1536, 1536x1024 | Chooses the correct official example row |
quality | low, medium, high | Chooses the correct output example |
has_image_input | true or false | Separates simple generation from edit/reference jobs |
partial_images | 0, 1, 2... | Adds output-token workload |
retry_count | 0, 1, 2... | Counts extra generated outputs |
route | direct, Batch, provider | Keeps contract owner visible |
If you track those fields in logs, you can answer the questions that matter later: which quality tier drives most spend, whether edit jobs cost more than simple generation, whether Batch is actually eligible, and whether a provider route is worth considering for a specific workload.
FAQ
How much does one GPT Image 2 image cost?
For official OpenAI output examples checked on May 6, 2026, a 1024x1024 image costs $0.006 at low quality, $0.053 at medium quality, or $0.211 at high quality. Portrait or landscape examples at 1024x1536 or 1536x1024 are $0.005, $0.041, or $0.165. The real API bill can be higher if your request uses input text, image inputs, edits, partial images, or retries.
Is $0.211 the GPT Image 2 price?
No. It is the official high-quality 1024x1024 output example. Low and medium quality are much lower, non-square examples differ, and all-in API bills can include other inputs or route effects.
Does GPT Image 2 have a free official API route?
Do not budget this as a free official API model. Treat the official API as paid unless OpenAI's current model page and pricing page say otherwise for your account and organization. ChatGPT app access is a separate consumer-product question, not the same as API billing.
Does Batch make GPT Image 2 cheaper?
OpenAI Batch can reduce official pricing for eligible asynchronous workloads, including image output rows. It is useful when your job can wait and when the workflow fits Batch semantics. It is not the right comparison for an interactive user who needs immediate image output.
Are provider prices comparable to OpenAI direct pricing?
Only after you label the owner and billing unit. A provider flat-call price is a separate gateway contract. It may help with access, payment, or testing, but it should not be presented as OpenAI direct API pricing. Use the provider-specific route guide when provider selection is the actual decision.
Which official pages should I check before budgeting?
Use the OpenAI API pricing page for token rows and Batch rows, the OpenAI image generation cost guide for per-image examples and formula language, and the GPT Image 2 model page for model identity and API route details.
