The Per-Image Price Is a Guess: What One AI Edit Really Costs
Every team shipping an image feature now has a spreadsheet cell labelled cost per image. Almost nobody has verified it against a bill.
A developer running a small photo editor recently did the unglamorous thing: pushed the same source photos through three different image models — Google's via the Gemini API, two OpenAI image models via fal.ai — and then read the actual invoice instead of the pricing page. The measurements were taken in the first days after one of those models launched. The finding is not exotic. It is the same finding that shows up in every serious cost review: the per-image estimate and the cost of one real edit are different numbers, and the difference is usually upward.
That gap is not a rounding error. For an indie tool it is the difference between a viable price and a slow bleed. For a product team it is a margin line nobody owns.
The sticker price is not the unit price

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: dev.to
Vendors price image models in a way that reads cleanly: a number per image, sometimes tiered by quality. That presentation is a convenience, not a contract. The billable event is a request, and a request contains several independently metered things at once:
- The input image. You are billed for the picture you send, not just the picture you get back. An edit is not a lookup; the model ingests your source pixels.
- The prompt and any reasoning tokens. Models that deliberate before rendering bill for the deliberation. That is invisible on a per-image table.
- The output image at a chosen resolution and quality tier. The same edit at a low resolution tier and at a high one are not the same product, and are not the same price.
So the honest mental model is not "$X per image." It is "cost = f(input size, prompt length, reasoning, output resolution, output quality, retries)." Six variables dressed up as one number.
Where the bill actually drifts
Four forces push real cost above the estimate, and all four are structural rather than accidental.
1. Resolution creep is user-driven. Nobody asks for the cheap tier. They ask for the sharpest one, because they are judging your product on the output, not on your cost sheet. A pricing table that quotes its friendly tier as the headline is quoting a tier your users will not pick.
2. Failed generations still bill. Users retry. Prompts get rejected, outputs come back wrong, someone regenerates four times because the first three were almost right. The cost per accepted output — the only number that matters — includes every abandoned attempt. Teams that divide monthly spend by successful outputs are often shocked; teams that divide by total requests are flattering themselves.
3. Reasoning is a cost you cannot see from outside. A model that thinks before it draws behaves better on complex edits and costs more per call. Your per-image estimate was probably built on a simpler call than the one your power users make.
4. Averages hide your worst users. Cost per edit is not a distribution with a single centre. It has a long tail — the person doing 4K retouches on large source files — and that tail is precisely your most engaged, most retained, most vocal customer.
Why this matters more than it sounds

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: dev.to
If you price a feature on an estimated cost per image and your measured cost per edit is meaningfully higher, you have not made a small forecasting error. You have inverted your business model. Every unit sold at a loss is a unit of growth working against you: more usage means more burn, and the users who love you most cost you the most.
This is the classic trap of compute-backed products. Unlike seat-based software, the marginal cost never goes to zero. You cannot outgrow a negative unit margin — you can only outrun it until the funding or the patience ends.
And the inverse is just as real: teams that do measure often discover headroom. The expensive tier is being used by 4% of users, the retry rate is fixable with better prompting or a cheap pre-check, and a modest price adjustment converts a loss-making feature into a modestly profitable one. Measurement is not only defensive.
The counterpoint: isn't this just an early-market tax?
Yes, partly — and it is worth taking seriously.
Image model prices have fallen fast, and every generation of models has made the same edit cheaper. Providers add caching, batching, and cheaper tiers. A cost model you build today may be obsolete in two quarters. There is a real argument for not over-engineering cost instrumentation around prices that will halve.
Two things blunt that argument.
First, the problem is the spread, not the level. Falling prices lower the average and leave the variance intact. A cheap model still has a 4x gap between its lightest and heaviest request. If your pricing collapses that gap into one number, you will still be wrong after the price cut — just wrong at a lower absolute cost, which is the most comfortable way to lose money slowly.
Second, cheaper unit prices expand usage. When a high-resolution output becomes affordable, it becomes the default. Cost per user does not fall as fast as cost per unit, because behaviour re-inflates the bill. The teams that survive price transitions are the ones that already know their cost per accepted output, so they can re-run the number the week a new model ships.
There is also a counterpoint to the counterpoint worth naming: not every product needs this rigour. If image generation is a garnish on a product with strong subscription economics, an estimate is fine. The moment images become the product — the thing users pay for — the estimate becomes a liability.
Price on measurement, not on the price list
A practical rule: never publish a price for a metered feature until you have logged the cost of at least a few hundred real requests from real users, including the failures.
That means three numbers, kept current: cost per request, cost per accepted output, and p95 cost per edit for your heaviest tier. Price your entry plan on the median and your heavy plan on the p95 — because the heavy plan is a promise to the people in the tail, and the tail is who will find the 4K button.
Key takeaways
- The billable unit for an image edit is a request — input image, prompt, reasoning, output resolution and quality, retries — not a picture.
- Measured cost per edit reliably exceeds per-image estimates, and the drivers are structural: resolution creep, failed generations, invisible reasoning, and a long tail of heavy users.
- Pricing on an estimate is not a small forecasting miss; it inverts the unit economics of a compute-backed product.
- Falling model prices do not fix the problem, because variance persists and cheaper units expand usage.
- The fix is instrumentation before pricing: log cost per request, cost per accepted output, and p95 cost per edit.
Next steps — a 30-day plan
Week 1 — Instrument. Log every image request with: input size, output resolution and quality tier, prompt token count, reasoning tokens if exposed, retries, and whether the user accepted the result. Tag by user and plan.
Week 2 — Measure the real number. Compute cost per request, cost per accepted output, and p50/p95 cost per edit per user tier. Compare each against the number in your pricing spreadsheet. Write down the gap explicitly; that gap is your current gross margin on the feature.
Week 3 — Attack the variance, not just the average. Add a cheap pre-check or prompt template to cut retries. Cap the top resolution tier behind a plan or a credit. Consider a cheaper model for the exploratory pass and the premium model only for the final render.
Week 4 — Re-price with evidence. Set the free tier on cost per request, the standard plan on the median accepted output, and the heavy plan on p95. Publish, then keep the dashboard live — and re-run the comparison on the day your next model upgrade ships, before you change a single price.
Sources
- Dev.to — GPT Image 2.6 pricing: what one edit really costs on fal, measured: https://dev.to/lygerone/gpt-image-26-pricing-what-one-edit-really-costs-on-fal-measured-5aan



