Research-backed calculator guide

AI Image Editing vs Regeneration: When Is a Fix Cheaper?

Learn how to calculate AI image editing cost per image, compare an edit with a full regeneration, and budget input tokens, retries, and accepted outputs.

What “AI image editing cost per image” should include

“Per image” can describe several different units. A provider may charge per output image, per million image tokens, per second of GPU time, per credit, or per subscription allowance. Replicate, for example, says some public models are billed by runtime while others are billed by input and output, and its pricing page shows example output-image rates for named models.^[5] A subscription credit is not the same thing as a model-call quote, because the effective price depends on how fully you use the allowance and whether edits, upscales, or high-resolution outputs consume different credits.

Start by naming the unit you are budgeting:

• One model attempt: one accepted or rejected image response.
• One source-image edit: one request that sends an existing image plus an instruction.
• One output image: one returned image, which may be one of several outputs in a request.
• One accepted asset: the deliverable that survives review. This is usually the most useful business unit.
• One workflow: the source upload, edits, regenerations, moderation, storage, review, and delivery needed to ship the asset.

The accepted-asset unit matters because a $0.03 output is not a $0.03 deliverable if you normally create four variants and keep one. At a 25% selection rate, four $0.0336 outputs already cost $0.1344 before input tokens, storage, or review time. That is still a low direct model bill, but it is the honest cost of that selection pattern.

Editing, inpainting, and regeneration are different cost paths

A flat-image edit supplies a source image and a prompt such as “remove the red cup from the right side.” The model may redraw the whole output even if the requested change is small. Inpainting can limit the changed region, but it still normally consumes a model call. Regeneration starts from a prompt, reference, or previous context and creates a new output. Unless the provider meters these operations differently, their direct cost is determined by the same billing ingredients: input units, output units, model, quality, resolution, and processing tier.

A layered workflow is different. If the headline remains real text, a designer can change it without invoking an image model. A logo can be swapped as an ordinary asset. A page can be resized by layout code. Only the background or product layer that needs new pixels requires an image-model call. That is why “edit” should be split into generative and non-generative operations: a local text, layout, or asset change can add zero model calls, while a layer that needs new pixels adds one.

How to calculate the cost per accepted image

Use five steps.

1. Record the provider meter

Write down whether the provider charges image input tokens, image output tokens, text tokens, seconds, credits, or a fixed subscription. OpenAI currently lists GPT Image image inputs at $8 per million image tokens and image outputs at $30 per million image tokens, alongside a $5 per million text-input rate on its pricing page. It also states that images are converted into tokens and charged per token.^[1] Do not turn those rates into a per-image number until you know the usage units for your request.

Google provides a more direct example for Nano Banana 2.1: a 1K output consumes 1,120 image tokens, which it equates to $0.0336 at the Standard output rate. A 2K output consumes 1,680 tokens and is listed at $0.0504; a 4K output consumes 3,780 tokens and is listed at $0.113. Batch equivalents are lower, but Batch is a different processing choice and may not suit an interactive editing experience.^[3]

2. Count source-image and prompt inputs

An edit usually sends an existing image, so count that image input. Also count the text instruction and any conversation history or reference images the API includes. If the response includes a new image, count output image units separately. Never assume that a small visual change means a small billed input; the provider’s tokenizer and image representation decide that.

3. Count all attempts, not just the final file

If three attempts are made and one is approved, the numerator contains all three attempts. Include safety or moderation calls if they are separately billed. Include a fallback provider if the original call times out after the provider accepted it. A durable request ID and usage log can prevent a retry from becoming an untracked duplicate.

4. Add non-model costs only when they matter

Storage, CDN delivery, image conversion, human review, and engineering time can dominate a high-volume feature even when model output is cheap. Keep these in separate columns so a provider quote is not confused with your fully loaded cost. For a small one-off calculation, it is reasonable to report direct model cost first and then list exclusions.

5. Divide by accepted outputs

If 10 calls produce two approved assets, divide total direct spend by two, not by ten. Track selection rate, average attempts per accepted asset, and resolution mix. This also lets you compare an edit policy with a regeneration policy using the same quality threshold.

Worked cost example: one flat-image fix versus regeneration

Assume an English-US product workflow checked on November 2, 2026. The team uses Google Nano Banana 2.1 Standard at 1K output. The quoted output rate is $0.0336 per 1K image. The quoted input rate is $1.50 per million text/image tokens.^[3] These are the vendor inputs. The following usage counts are planning assumptions chosen to make the arithmetic inspectable, not a claim about every image request:

• A flat-image edit sends 2,000 input tokens for the source image and instruction.
• A text-only regeneration sends 500 input tokens for its prompt.
• Each attempt returns one 1K image.
• Three attempts are needed before one output is approved.
• No storage, review labor, moderation, or delivery charges are included.

Under these assumptions, a flat-image edit is slightly more expensive than text-only regeneration because it sends more input tokens, even though the requested change is smaller. The difference is only $0.00675 across three attempts. The important result is not that regeneration always wins. It is that a paid edit call does not become free just because the instruction says “change one detail.”

The layer-only row is the real cost lever. If the headline, crop, or logo can be changed in the editor without new pixels, the incremental model cost is zero. If only the background needs a new render, you pay for one layer call instead of regenerating the entire composition. You still need to budget application work, export, review, and storage, but those are different line items.

For a different provider, substitute the provider’s meter rather than copying this number. Replicate’s published examples include $0.04 per output image for FLUX 1.1 Pro and $0.025 for FLUX Dev, while also explaining that many models are billed by runtime. Those figures are useful comparison anchors for output generation, not a guaranteed price for an edit endpoint or for a particular resolution.^[5]

When editing is cheaper

Editing is usually cheaper when it reduces paid attempts or limits the number of new pixels. Examples include a mask that lets the model preserve most of a composition, a layer regeneration that leaves other layers untouched, or a multi-turn workflow where the accepted image is refined instead of restarting from a blank prompt. The saving comes from avoided calls and avoided rejected outputs, not from the word “edit” in the endpoint name.

Editing is also cheaper when it preserves expensive context. A branded product scene may require several attempts to get the logo, layout, and product placement right. Rebuilding the entire scene can reintroduce those errors. A targeted layer edit may cost one call while preserving the already approved elements. That quality and rework benefit should be measured alongside the direct per-call price.

When regeneration is cheaper

Regeneration can be cheaper when the source image is large, the edit includes many reference images, or the provider’s image-input meter is expensive. It can also be cheaper when the original composition is not worth preserving. For a decorative image with no locked subject, brand mark, or exact text, a short prompt and one output may be simpler than uploading a large source and asking for a constrained edit.

Use the same acceptance rule for both paths. If a regeneration tends to pass review in one attempt while an edit needs several attempts because the model keeps changing protected details, the cheaper nominal operation may be the more expensive workflow. Conversely, do not pay for a new image when a deterministic crop, resize, text change, or asset swap can produce the required result locally.

Budgeting checklist and limitations

Before publishing a number as “cost per image,” document the model ID, date checked, currency, processing tier, output resolution, quality setting, number of outputs per request, input-image count, average attempts, selection rate, and whether batch pricing applies. Record usage from the provider response where possible. A pricing page is a quote for a meter, not proof of your application’s average usage.

This guide’s worked example excludes human review, storage, bandwidth, image decoding, moderation, failed requests, taxes, subscription minimums, and engineering time. It also assumes that the vendor’s listed rate remains valid for the date and tier shown. Google’s documentation notes that model availability and discounts can change, while OpenAI and Replicate expose different billing shapes. Recheck the primary pricing page before committing budget.^{[1] [3] [5]}

For a token-based companion calculation, use the AI token cost calculator. To compare several model meters side by side, use the model pricing comparison. If image work is one step inside a larger agent or content workflow, the LLM cost calculator can help keep text, tool, and model costs in the same forecast.

FAQ

Is AI image editing cheaper than generating a new image?

Not necessarily. If both actions create one paid output, their output charge can be the same. Editing may add input-image tokens, while regeneration may use only a short text prompt. Editing becomes cheaper when it avoids retries, regenerates only one layer, or lets the user change text and layout without another model call. Compare the complete attempt and acceptance history rather than the endpoint label.

What is a reasonable way to measure cost per edited image?

Measure direct model spend for every attempt, then divide by the number of approved outputs. Keep input-image cost, input-text cost, output-image cost, and retries in separate fields. Report a second fully loaded figure if storage, moderation, human review, or delivery is material. This prevents a low output quote from being mistaken for the cost of a shipped asset.

Do input images increase image-editing API cost?

They can. OpenAI states that image inputs are converted into tokens and billed at the applicable image-input rate.^[1] Google likewise publishes input pricing for text/image/video on its image models.^[3] The exact count depends on the provider, model, image representation, resolution, and request context. Use the usage record from the actual request instead of guessing from file size alone.

Can a layer edit cost zero?

A layer edit can have zero incremental model cost when it is a normal application operation: changing real text, swapping an approved logo asset, moving an element, or resizing a canvas. If the change requires new pixels from a generative model, count a new model call. The zero-cost case is a workflow design choice, not a general promise that all image edits are free.

Should I use per-image pricing or token pricing for a forecast?

Use the provider’s native meter first. Per-image equivalents are convenient when the vendor publishes them for a defined model and resolution, as Google does for Nano Banana 2.1.^[3] Token-based pricing is more transparent when input images, prompt context, or output quality vary. For a mixed provider stack, normalize each request into dollars per attempt and then calculate dollars per accepted asset.

What costs are excluded from a simple per-image estimate?

A direct model estimate may exclude storage, CDN delivery, image conversion, moderation, queueing, human review, rejected-output retention, subscription minimums, and engineering or support time. State those exclusions beside the number. For a product decision, calculate both direct model cost and fully loaded cost when the omitted items could change the choice.