GPT Image 2.5 edit chains: four high passes cost one max image

A four-pass edit chain at high quality costs the same output price as one max image at 1024×1024 before input tokens and Sume pricing: 4 × $0.05268 = $0.21072. fal's guide and Sume's docs both give $0.21072 for max, so the choice between one big prompt at max and four small passes is a real trade, not a rounding detail.

Numbers come from fal's How To Use GPT Image 2.5 (read 2026-10-02) and Sume's Image API page, which uses the same Fal token rates. Edit advice comes from OpenAI's Image prompting guide. Your billed amount is the usage.cost in each response.

Why would anyone chain passes?

Both guides recommend it. fal says one change per pass, because combining several edits in one instruction raises the chance of a retry. OpenAI says to pass the previous output as the next edit input, request one change and repeat the details to preserve. The same guides warn that repeated edits can still shift details you meant to keep, so each pass needs its constraint sentence.

What does a chain cost at 1024×1024?

These are output-image prices only at 1024×1024. Input tokens (references) and Sume's pricing are added on top, and the figures are estimates from the vendors' calculator.

How do I keep the cost down?

Run the early passes cheaply and the last one at the quality you ship. A pass at low is about one ninth of a high one. If a pass is not what you wanted, only a completed image is billed; a failed generation is not. Sume's docs also note that auto quality reserves max, so set a quality explicitly when you budget.

• Pick the edit order so the riskiest change comes first.
• Use low or medium while you test wording.
• Finish at high or above only once.
• Sum usage.cost in your own code.

How do I sum a chain on Sume?

This script applies one instruction per pass, feeds each result back as the next reference, and prints the running usage.cost. If Sume rejects a result URL as a reference, save a copy and re-host it on a public HTTPS address. It needs pip install requests.

import os, requests

STEPS = ["Brighten the sky.", "Remove the bin on the left.",
         "Warm the colour grade slightly."]
KEEP = "Keep everything else exactly as it is."
url = "https://example.com/photo.jpg"
total = 0.0
for i, step in enumerate(STEPS):
    quality = "high" if i == len(STEPS) - 1 else "low"
    r = requests.post(
        "https://api.sume.com/v1/images",
        headers={"Authorization": f"Bearer {os.environ['SUME_API_KEY']}"},
        json={"model": "openai/gpt-image-2.5",
              "prompt": f"Image 1 is the photo to edit. {step} {KEEP}",
              "quality": quality,
              "input_references": [
                  {"type": "image_url", "image_url": {"url": url}}]},
        timeout=60,
    )
    r.raise_for_status()
    body = r.json()
    url = body["data"][0]["url"]
    total += body["usage"]["cost"]
    print(i + 1, quality, url, f"running cost {total:.4f}")

When is one max pass the better choice?

When the instruction is a single clear change and the quality of fine detail matters most, one max image can be cheaper in your time than a chain, because there are fewer places for drift. When you are exploring wording, the chain at low is far cheaper. The prices above do not decide it alone; the number of retries does.

Whichever you choose, set the quality explicitly. Sume's docs say an auto quality reserves max, and an omitted value defaults to high.