Which Image API Provider to Use for GPT Image 2.5 Sunburst Editing in Production

The most expensive GPT Image 2.5 Sunburst edit is the one where nobody set quality: GMI Cloud's model catalog states that "quality=auto (or omitted) is billed at the max tier," which is $0.2107 per 1024x1024 output instead of $0.0132 at medium, almost 16 times more (as of September 2026, GMI Cloud model library).

For production editing, run Sunburst on GMI Cloud's Model-as-a-Service (MaaS) platform, where gpt-image-2.5-sunburst-edit supports masks, up to 16 input images, and transparent backgrounds, and every quality tier has a published per-image price.

Production integration comes down to setting two fields explicitly on every request, quality and size; this guide covers the request that locks both, what 10,000 catalog edits cost per month, and the integration checklist for a product-image pipeline.

Which provider should you use for GPT Image 2.5 Sunburst editing in production?

For GPT Image 2.5 Sunburst editing in production, use GMI Cloud MaaS.

GMI Cloud is an AI-native infrastructure platform built for production AI inference, and its MaaS layer serves LLM, image, video, and audio models through one API design, one API key, and one invoice (About, MaaS).

For a team editing product images at volume, that combination matters more than the model endpoint alone:

• Tier prices you can budget against. The catalog pricing note lists the 1024x1024 output price for all five tiers and states that "explicit tiers are priced exactly," so each job can be budgeted before it runs.
• The full edit surface. gpt-image-2.5-sunburst-edit takes image (a URL, a base64 data URI, or an array of up to 16), mask for inpainting, background: transparent for cutouts, n for 1 to 10 variants per call, plus size, quality, output_format, moderation, and user.
• Both GPT Image 2.5 variants on the same key. Sunburst ("the most capable GPT Image 2.5 variant, tuned for the highest editing precision") and Flare ("fastest variant") are both listed for generation and editing "at identical pricing," so switching variants is a model-ID change.
• Production plumbing documented. An async request queue with status polling, an Upload API that returns a stable public URL for your source photos, and a Serverless Usage view you can filter by API key and model.
• Production terms on the platform. The MaaS page lists "Guaranteed SLAs with uptime and performance commitments" and "Centralized billing with a single invoice across all models."

How GMI Cloud MaaS compares with the other ways to call the same model:

Provider (Sunburst edit access / Pricing as published (September 2026) / Default quality behavior)

• GMI Cloud MaaS | Sunburst edit access: gpt-image-2.5-sunburst-edit (plus -generate and both Flare endpoints) | Pricing as published (September 2026): Per-tier 1024x1024 prices: low $0.0059 to max $0.2107 | Default quality behavior: auto or omitted is billed at max; set an explicit tier
• OpenAI API | Sunburst edit access: gpt-image-2.5-sunburst on v1/images/edits | Pricing as published (September 2026): $5 text input, $8 image input, $30 image output per 1M tokens | Default quality behavior: Six settings including auto
• fal | Sunburst edit access: openai/gpt-image-2.5/sunburst/edit | Pricing as published (September 2026): High at 1024x1024: $0.05268 | Default quality behavior: Defaults to high
• Replicate | Sunburst edit access: openai/gpt-image-2.5-sunburst | Pricing as published (September 2026): Billed by Replicate, or bring your own OpenAI key | Default quality behavior: auto is the default

Sources: OpenAI model page, fal model page, Replicate model page.

GMI Cloud matches OpenAI's per-token rates for this model ($5, $8, and $30 per 1M tokens) and adds what a catalog pipeline needs around it: the image editor sits on the same account, key, usage view, and invoice as the LLMs, video, and audio models your product team already calls.

What does one Sunburst edit cost on GMI Cloud?

On GMI Cloud MaaS, one Sunburst edit costs the output tier price plus the reference images plus the prompt text. From the catalog pricing note for gpt-image-2.5-sunburst-edit, as of September 2026 (model library):

Component (Price)

• Output, 1024x1024, low | Price: $0.0059 per image
• Output, 1024x1024, medium | Price: $0.0132 per image
• Output, 1024x1024, high | Price: $0.0527 per image
• Output, 1024x1024, xhigh | Price: $0.0937 per image
• Output, 1024x1024, max (also auto or omitted) | Price: $0.2107 per image
• Each reference image | Price: Up to 1,536 input tokens at $8/M, "up to $0.0123/image"
• Prompt text | Price: $5/M tokens, about 1 token per 3 bytes

This also helps read the single number on the MaaS page, where gpt-image-2.5-sunburst-edit shows $0.025538/Request.

The page does not break that figure down, but it equals the generate endpoint's $0.01325 headline price plus one full-size reference image (1,536 _ $8/M = $0.012288). Treat it as a headline figure rather than a flat rate: add a second product shot or move to high, and the charge moves with it.

Treat size the same way as quality: set it on every request and avoid auto, which leaves the pixel count, and with it the price, to the model.

An omitted size falls back to 1024x1024, so the risk is drift rather than a max-tier surprise: a template change that starts sending 1536x1024 or auto can change output costs and invalidate the 1024x1024 budgets in this guide without anyone touching quality.

The parameter list defaults size to 1024x1024, the endpoint also accepts the presets 1024x1536 and 1536x1024, and a custom WxH works when both edges are multiples of 16, each edge is at most 3840px, the aspect ratio is at most 3:1, and the total is between 655,360 and 8,294,400 pixels.

The tier prices above are for 1024x1024, and the catalog's pricing note says "Other sizes scale with pixel count." Before sending a full catalog at any other size, run a 20-image test batch at that size on a dedicated API key, then divide the key's charge in Serverless Usage by the number of images it produced.

How much do 10,000 product-image edits cost per month?

On GMI Cloud MaaS at medium quality, 10,000 single-image Sunburst edits cost about $260 a month; the same batch with quality omitted costs about $2,235.

The table assumes one product photo per edit at the full 1,536-token reference cost ($0.0123) and a 300-byte prompt (about 100 tokens, $0.0005), with prices as of September 2026:

low

• Output: $0.0059
• + reference + prompt: $0.0128
• Per edit: $0.0187
• 10,000 edits / month: $187

medium

• Output: $0.0132
• + reference + prompt: $0.0128
• Per edit: $0.0260
• 10,000 edits / month: $260

high

• Output: $0.0527
• + reference + prompt: $0.0128
• Per edit: $0.0655
• 10,000 edits / month: $655

xhigh

• Output: $0.0937
• + reference + prompt: $0.0128
• Per edit: $0.1065
• 10,000 edits / month: $1,065

max, auto, or omitted

• Output: $0.2107
• + reference + prompt: $0.0128
• Per edit: $0.2235
• 10,000 edits / month: $2,235

The numbers point to three rules:

1. The omitted field is a $1,975-a-month bug. A pipeline that forgets quality pays 8.6 times the medium bill for the same 10,000 images.
2. Reference images dominate cheap tiers. The input photo is about two-thirds of a low edit and about half of a medium edit. A composite that sends a product shot plus a second reference image adds another $0.0123, which takes a medium edit to $0.0383 and the monthly batch to $383.
3. Tier choice moves the bill more than anything else. Moving the bulk of a catalog from high to medium saves $395 per 10,000 edits, while GMI Cloud, OpenAI, and fal all publish the same $5, $8, and $30 per-1M token rates for this model.

Which quality tier should each edit type use?

Default every Sunburst pipeline to medium and promote only the images that fail review. A rule set that keeps the monthly bill predictable:

Edit type (Tier / Why)

• Prompt testing, thumbnails, A/B drafts | Tier: low | Why: Cheapest way to check that an instruction does what you expect
• Background swap or cleanup for marketplace listings | Tier: medium | Why: The workhorse tier; the $0.0260 per edit row above
• Hero images, packaging with readable text | Tier: high | Why: Worth the extra $0.0395 per edit when a person will look closely
• Final campaign assets reviewed by a designer | Tier: xhigh or max | Why: Reserve for a handful of images per campaign, never for batch jobs

For a catalog of 10,000 SKUs on GMI Cloud MaaS, a split of 9,000 medium edits and 1,000 high edits costs 9,000 _ $0.0260 + 1,000 _ $0.0655 = $299.50 a month, against $2,235 for the same catalog sent without a tier.

Put the tier in the job record, not in a code default, so a reviewer can see why an image cost what it did.

How do you send a background swap, a masked edit, and a multi-image composite?

A background swap, a masked edit, and a multi-image composite all go to the same GMI Cloud MaaS endpoint with the same model ID, gpt-image-2.5-sunburst-edit; only the payload changes.

Requests go to POST https://console.gmicloud.ai/api/v1/ie/requestqueue/apikey/requests with your GMI Cloud API key as a Bearer token (Video API Reference, which documents the shared request queue).

Background swap (no mask). Send the product photo and the instruction:

{
  "model": "gpt-image-2.5-sunburst-edit",
  "payload": {
    "prompt": "Replace the background with a plain light-gray studio sweep. Keep the product, its label, and its shadow unchanged.",
    "image": "https://your-bucket.example.com/sku-4417/front.png",
    "size": "1024x1024",
    "quality": "medium",
    "output_format": "png"
  }
}

Masked edit (inpainting). Add a mask.

Per the catalog, "Transparent (alpha=0) pixels are edited, opaque pixels are preserved," and the mask "must be the same dimensions as the input image and must carry an alpha channel." Export it as PNG with alpha; a mask saved as JPEG has no alpha channel.

{
  "model": "gpt-image-2.5-sunburst-edit",
  "payload": {
    "prompt": "Change the tabletop in the masked area to light oak. Do not alter the bottle.",
    "image": "https://your-bucket.example.com/sku-4417/lifestyle.png",
    "mask": "https://your-bucket.example.com/sku-4417/lifestyle-mask.png",
    "size": "1024x1024",
    "quality": "medium"
  }
}

Multi-image composite or transparent cutout. Pass an array to image (up to 16) for compositions, and set "background": "transparent" with png or webp output when you need a cutout for your own templates. Each extra input image adds up to $0.0123.

If your source photos are not publicly reachable, GMI Cloud's Upload API returns a pre-signed upload_url (valid for about 15 minutes) and a stable public_url to reference in the request. It accepts jpeg, jpg, and png files.

What does a production-safe edit call look like?

A production-safe call to the Sunburst edit endpoint on GMI Cloud MaaS does three things a quickstart does not: it refuses to send a request without an explicit tier, it draws every wait from one time budget, and it returns only on success with at least one output URL.

The Sunburst edit catalog entry lists synchronous delivery, and its example response already carries status: success and outcome.media_urls; the request queue's general pattern is to poll GET .../requests/{request_id} while a job is still pending.

The function below handles both paths.

import os
import time
import requests

BASE = "https://console.gmicloud.ai/api/v1/ie/requestqueue/apikey"
HEADERS = {
    "Authorization": f"Bearer {os.environ['GMI_API_KEY']}",
    "Content-Type": "application/json",
}
MODEL = "gpt-image-2.5-sunburst-edit"
TIERS = {"low", "medium", "high", "xhigh", "max"}   # "auto" is billed at max
PENDING = {"dispatched", "queued", "processing"}
def edit_image(image_url, prompt, quality, mask_url=None,
               on_submit=None, deadline_s=180):
    if quality not in TIERS:
        raise ValueError(f"explicit quality tier required, got {quality!r}")

    payload = {"prompt": prompt, "image": image_url, "size": "1024x1024",
               "quality": quality, "n": 1, "output_format": "png"}
    if mask_url:
        payload["mask"] = mask_url

    stop_at = time.monotonic() + deadline_s      # one budget for the whole job

    def remaining():
        left = stop_at - time.monotonic()
        if left <= 0:
            raise TimeoutError(f"edit exceeded {deadline_s}s")
        return left

    resp = requests.post(f"{BASE}/requests", headers=HEADERS,
                         json={"model": MODEL, "payload": payload},
                         timeout=min(120, remaining()))
    resp.raise_for_status()
    job = resp.json()
    request_id = job.get("request_id")
    if not request_id:
        raise RuntimeError(f"no request_id in response: {job}")
    if on_submit:
        on_submit(request_id)                    # persist before waiting

    while job.get("status") in PENDING:          # skipped if POST already finished
        time.sleep(min(2, remaining()))
        poll = requests.get(f"{BASE}/requests/{request_id}",
                            headers=HEADERS, timeout=min(30, remaining()))
        poll.raise_for_status()
        job = poll.json()

    if job.get("status") != "success":
        raise RuntimeError(f"{request_id} ended as {job.get('status')!r}")
    media = (job.get("outcome") or {}).get("media_urls") or []
    urls = [m["url"].strip() for m in media
            if isinstance(m, dict) and isinstance(m.get("url"), str)
            and m["url"].strip().startswith(("https://", "http://"))]
    if not urls:
        raise RuntimeError(f"{request_id} succeeded with no output URL")
    return request_id, urls

Every timeout and sleep is capped by the remaining budget, and no new wait starts once the budget is spent. A success returned by a call already in flight is still accepted, even if it arrives after the budget, so the worker keeps a finished edit instead of discarding it.

A timeout, a non-success status, or a success without an http(s) output URL all raise with the request ID, so a failed edit can never reach your catalog as a blank image. The on_submit hook is where your job table records the request ID, which is what makes the retry rules below safe.

What belongs on the production integration checklist?

A production Sunburst integration on GMI Cloud MaaS needs eight checks: explicit tier and size, job keys, safe retries, rate-limit planning, moderation, mask validation, output storage, and per-workflow spend tracking.

1. Explicit tier and size on every request. Validate quality in code as above, pin size to the value you priced, and alert on any request logged without either.
2. One job key per edit. Hash everything that changes the output into a job key: model ID, source image version, mask version, prompt, tier, size, and output format. If a job with that key already has a request_id, poll it instead of resubmitting.
3. Retry only what provably never started. Retry automatically, with exponential backoff, when the submit got an HTTP 429 response or failed to connect at all (requests.exceptions.ConnectTimeout, or a refused connection). A read timeout or a dropped connection after the request was sent is ambiguous: the edit may have run, so flag the job for review instead of resubmitting. Once you hold a request_id, keep polling that job; a second submit is a second paid edit.
4. Rate-limit tiers planned before launch. GMI Cloud enforces rate limits per organization, starts every organization at Tier 1, and upgrades automatically within 24 hours of credit purchases of $50, $500, and $1,000. Vouchers do not count, quotas differ by model within each tier, and a manual upgrade goes through [email protected] (Rate limits).
5. Moderation and abuse attribution. Keep moderation at auto for seller-uploaded images, and send a stable, hashed seller ID in user, which the catalog says is "forwarded to OpenAI for abuse monitoring."
6. Mask validation before submit. Check dimensions and alpha channel locally, so a bad mask fails in your worker in milliseconds instead of as a queued job.
7. Copy outputs to your own storage. Results come back as URLs in outcome.media_urls. Download each file into your asset store when the job succeeds, so the catalog never depends on a delivery link.
8. Spend by workflow. Give each workflow (background swap, inpainting, composites) its own API key. The Serverless Usage view filters by API key and model at daily or hourly granularity, so a tier mistake shows up in the daily view instead of on the invoice.

How can merchandising teams test Sunburst edits before engineering wires the pipeline?

Connect the GMI MCP Server to Claude, ChatGPT, or Cursor and let the people who own the catalog price and test edits in plain language.

The server treats estimates as "a first-class tool": an agent "can price any job before running it," and every job "lands in your console history and billing like any other usage." The MCP FAQ recommends asking the agent to search for currently available models, so the first prompt is usually "find the GPT Image 2.5 edit models and quote a medium 1024x1024 edit." Setup takes one URL and a GMI Cloud sign-in, covered in GMI MCP Server: turn your assistant into a production studio.

For drafts where a flat per-image price matters most, the same key also reaches models such as Hy Image 3.5 Preview; Why Hy Image 3.5 Preview Matters covers how its edits held up across repeated product shots.

Teams that also run private image steps next to API models can read Seedream 5.0 Pro and private image workflow versioning; video is covered in testing Luma Ray 3.2 and Kling 3.0 Turbo together, and consent-based voice work in authorized voice cloning with MiniMax Speech 2.8.

FAQ

What happens if I don't set quality on a GPT Image 2.5 Sunburst edit?

On GMI Cloud, an omitted quality or quality: "auto" is billed at the max tier, $0.2107 per 1024x1024 output as of September 2026, because auto's consumption adapts per request and cannot be priced in advance. Setting medium explicitly costs $0.0132 for the same output size.

For 10,000 edits a month, that one field is the difference between about $260 and about $2,235 including the reference image.

How do I pass a mask for inpainting?

Add a mask field next to image in the gpt-image-2.5-sunburst-edit payload, pointing to a publicly reachable mask file, as in the catalog's inpainting example.

The mask must match the input image's dimensions and carry an alpha channel: transparent pixels (alpha=0) are edited and opaque pixels are preserved. Export masks as PNG, since JPEG has no alpha channel.

Should bulk product edits use Sunburst or Flare?

Use Sunburst for product edits that must leave the item and its label untouched, and Flare where turnaround speed matters more. On GMI Cloud, GPT Image 2.5 Sunburst and GPT Image 2.5 Flare have identical pricing and parameters, so the choice is about output, not cost.

The catalog describes Sunburst as "tuned for the highest editing precision" and Flare as the "fastest variant." Switching between them is a change of model ID, from gpt-image-2.5-sunburst-edit to gpt-image-2.5-flare-edit.

Can I edit product photos that aren't hosted publicly?

You can. GMI Cloud's Upload API returns a pre-signed upload URL, valid for about 15 minutes, and a stable public URL that you then pass in the image or mask field. It accepts jpeg, jpg, and png files. You can also send small images inline as base64 data URIs.

How do I see what each image-editing workflow spends on GMI Cloud?

Create a separate API key per workflow and open Billing, then Serverless Usage, in the GMI Cloud console. The view filters by API key and model name at daily or hourly granularity, so background swaps, inpainting, and composites each show their own spend.

All of it lands on the same invoice as the rest of your MaaS usage.

Start editing on GMI Cloud

Create a GMI Cloud account at the console, generate an API key, and send your first gpt-image-2.5-sunburst-edit request at medium using the payloads above; current per-tier prices are in the model library, and the MaaS page shows the headline per-request price.

If you are planning a catalog-scale batch or need a higher rate-limit tier before launch, contact our team and we will help size it.