Image API cost
Image generation bills per output, not per token — but the per-image price swings 50× between a 512px draft and a high-res edited output. The real cost driver is your regeneration rate: typical pipelines discard 1–3 images for every keeper, and each discarded attempt is billed.
The formula
Per-image price is an editable input because vendors quote by size/quality tier and change often — check your provider's current page and paste it. As of . Excluded: moderation retries and video models (different price class entirely).
Per-image pricing hides a fifty-fold spread
Image generation bills per output rather than per token, which sounds simpler than the token calculators on this site and is actually harder, because "an image" is not a unit. A 512-pixel draft and a high-resolution edited composite are both one image, and they differ in price by roughly fifty times.
| Tier | Typical price | What it is for |
|---|---|---|
| Draft / small | ~$0.003 | Composition, prompt iteration, thumbnails |
| Standard | $0.01–0.08 | Publishable output at normal resolution |
| High-res / edited | $0.10–0.25 | Final assets, inpainting, upscaling |
The practical consequence is that "what does an image cost" has no answer. "What does your image cost" does, and it is a question about your pipeline, not about the vendor's price list.
The regeneration rate is the real cost centre
Almost every production image pipeline throws work away. You generate several candidates, pick one, and pay for all of them. Typical discard rates run from one to three throwaways per keeper.
This is the single largest driver on the page and the one that never appears in a vendor's pricing table, because the vendor is paid for attempts and you are paid for results. The gap between the two is where image budgets go wrong — and it is also the most controllable number here, because a cheaper draft tier used for iteration reduces both the cost of each discard and the number of discards you need.
Edits, variations and the storage tail
Editing operations bill as generation. Inpainting a region, extending a canvas, or upscaling a draft are all priced operations, typically above a plain generation because they process a larger working area. Teams that budget "one image per asset" and then run two edit passes per asset have under-budgeted by a factor of three without noticing.
Storage is the opposite problem: negligible per operation, permanent in aggregate. Once you retain originals, derivatives and thumbnails, the library grows with everything you have ever made rather than with what you make this month.
Where teams get this wrong
- Budgeting at draft prices. The cheap tier is for iterating. If your production output is standard or high-res, planning at $0.003 understates the bill by an order of magnitude.
- Treating regeneration as an edge case. It is the normal case. A pipeline with zero discards is unusual enough to be worth verifying before you assume it.
- Assuming edits are included. They are separate billed operations with their own, usually higher, price.
- Ignoring moderation retries. Prompts that trip a filter and get retried still consume attempts on most providers.
- Comparing across modalities. Video, audio and images bill on incompatible axes. A single "generative media cost" line hides more than it reveals.
Cutting the bill
- Iterate cheap, render once. Use the lowest tier for exploration and a single high-tier pass for the final asset.
- Cache and reuse. Generated assets that get re-requested should never be regenerated.
- Reduce variation count deliberately. Four candidates instead of eight halves that line; whether quality suffers is measurable, so measure it.
- Tier your storage. Keep originals in cold storage and serve derivatives from cache.
The two-stage pipeline that keeps this bill under control
Almost every cost-efficient image pipeline has the same shape: iterate at the cheapest tier, render once at the expensive one. Prompt exploration, composition checks and rough approval all happen on drafts that cost a fraction of a cent, and only the asset that has been signed off gets a full-quality pass.
The reason this matters is that regeneration — not unit price — dominates the bill. When a discard costs a fraction of a cent, discarding generously is cheap and iteration gets faster. When a discard costs the same as a finished asset, every rejected attempt is a real budget line, and teams respond by iterating less and shipping worse output. The cheap tier is what makes discarding affordable, and affordable discarding is what makes the final asset good.