GPT Image 2 API cost and 50% B2C savings

The five usage legs on every GPT Image 2 bill

The bill for one request is sum(tokens in each leg × the leg's official rate) × 0.5 for a regular B2C account. Cached text and image input are billed at 25% of their fresh official rates before the discount — that is how $1.25 and $2 per million become $0.625 and $1 here. Nothing is rounded up per request: you pay for the exact tokens the terminal usage event reports, no per-call fee and no minimum image charge.

A worked example. Suppose terminal usage for one edit request reports 400 fresh text-input tokens, 1,500 fresh image-input tokens from one PNG reference, 600 cached text-input tokens and 2,000 image-output tokens. Officially that is 400 × $5 + 1,500 × $8 + 600 × $1.25 + 2,000 × $30 per million = $0.0015 + $0.012 + $0.00075 + $0.06 = $0.07425, and the regular B2C charge is exactly half: $0.037125. The cached leg saved $0.00225 officially versus fresh input — real, but small next to the $0.06 output leg, which is why output discipline moves the budget more than cache hunting.

See also: Generate and edit images with the GPT Image 2 API

Generation vs. edit: the endpoint sets the input bill

POST /v1/images/generations creates a new asset from a text prompt, so its bill is text input plus image output. POST /v1/images/edits accepts one to five PNG, JPEG or WebP references (each ≤50 MB), and every reference is metered as image input at $8/M officially — $4/M after the B2C discount. A single 2,000-token reference adds $0.016 officially ($0.008 here): cheap when it lifts acceptance, pure waste when the prompt alone would have passed review. Region inpaint via Responses image_generation uses the same image token legs; the mask is not billed as a second reference image.

• Reach for generation when the asset is new and the prompt fully describes it; text input at $5/M officially is the cheapest leg on the card.
• Reach for edits when a reference anchors composition, brand color or product geometry — pay the image-input leg once instead of burning image-output tokens on retries.
• Keep references PNG, JPEG or WebP and bounded in count: the endpoint accepts one to five files of at most 50 MB each, and each extra file is extra billed image input.
• Treat the shipped profile as fixed: one non-streaming PNG output with the documented opaque-or-transparent/low/proportion-preset controls; exact pixel dimensions are not promised on this subscription wire.

Production image-editing workflow: references, validation, retries →

Measure one real request before budgeting a batch

1. 01Call gpt-image-2 on POST /v1/images/generations for a new asset, or /v1/images/edits when one to five PNG, JPEG or WebP references genuinely improve the result.
2. 02Keep the shipped profile bounded: a single non-streaming PNG output with only the documented controls — background opaque or transparent, quality low, size as a proportion preset.
3. 03Read terminal usage from the response instead of estimating output tokens from PNG bytes or dimensions; the usage event is the billing authority.
4. 04Match the request against the dashboard charge and store its ID next to the generated asset, so per-image cost is a measured number, not folklore.

curl https://router.apitoken.sale/v1/images/generations \
  -H "Authorization: Bearer $APITOKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-image-2","prompt":"A clean studio product photograph","background":"opaque","quality":"low","size":"auto"}'

A trimmed response looks like this. Cost comes from the usage object, not from the payload size of b64_json:

{
  "created": 1771000000,
  "data": [{ "b64_json": "…" }],
  "usage": {
    "total_tokens": 3900,
    "input_tokens": 1900,
    "input_tokens_details": { "text_tokens": 1000, "image_tokens": 900 },
    "output_tokens": 2000
  }
}

Do not publish a made-up price per image. Output usage varies between requests, size is a proportion preset rather than a 2K/4K pixel lock, and the terminal usage event is the billing authority — quote measured numbers with their request IDs, or quote the rate card.

Cached input: a 75% discount you verify, not assume

Cached text input costs $1.25/M and cached image input $2/M officially — 25% of the fresh rates — before the same 50% B2C discount brings them to $0.625 and $1. On this route the provider decides what counts as cached; re-sending the same file does not guarantee the cached leg. The only proof is terminal usage reporting cached input for the request, so cache savings belong in the budget only after usage confirms them.

• Keep the stable prompt prefix byte-identical across batch items and push per-item variation to the end, so the shared prefix stays cache-eligible.
• Reuse the exact same reference bytes across a batch instead of re-encoding the PNG between calls.
• Score caching from the dashboard: compare cached legs in terminal usage across the batch and drop cache assumptions the usage does not confirm.
• Never budget at cached rates by default; budget at fresh rates and treat confirmed cache hits as upside.

Cost controls that survive batch volume

The 50% figure is the regular B2C policy applied after official usage is calculated. B2B accounts follow their negotiated policy, and OpenKeys bill at official 1:1 prices — a discount headline never replaces reading your own account class.

• Use generation for new assets and edits only where references measurably raise acceptance; each reference adds image-input cost.
• Reject unusable outputs against a fixed visual checklist and cap retries per asset — endless prompt retries erase a nominal token discount.
• Give the image worker its own API key with a lifetime spending limit so a runaway batch cannot drain the whole account balance.
• Reconcile terminal usage against dashboard charges after the first calls and on a schedule; per-image cost should come from measured usage, not from a blog average.

GPT Image 2 model page: rates, snapshot alias and limits →

Frequently asked questions

Related guides