# GPT Image 2.5 in ComfyUI: Setup, Cost per Run, and Fixes

> GPT Image 2.5 runs in ComfyUI 0.35.0+ as a Partner Node billed in Comfy credits, not an OpenAI key. A 1024×1024 image costs about $0.0084 at low quality.

- URL: https://blog.laozhang.ai/en/posts/gpt-image-2-5-comfyui
- Published: 2026-09-21
- Updated: 2026-09-25
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: AI Image Generation
- Tags: GPT Image 2.5, ComfyUI, Image Editing, Partner Nodes

---
GPT Image 2.5 works in ComfyUI through the built-in **OpenAI GPT Image 2.5** Partner Node, which needs ComfyUI 0.35.0 or later. There is nothing to download. The node sends your prompt and any reference images to OpenAI's servers, gets the finished image back into the graph, and a `Save Image` node writes it to disk.

What pays for the run is a Comfy account with a credit balance above zero. An OpenAI API key, a key from another provider, or a ChatGPT subscription can't be used in the node; Comfy's FAQ says bringing your own API key isn't supported yet. A 1024×1024 image costs about $0.0084 at the node's default `low` quality and about $0.0753 at `high`.

All prices below come from the price badge coded into the node and from Comfy's published credit rates as of September 25, 2026. They are estimates, not a measured bill. Your Credit History shows what a run actually cost.

## Before the first run: version, account, credits

Four things have to be true before the node will run:

1. **ComfyUI 0.35.0 or later.** Older installs don't show the node or its templates. On Comfy Cloud, new core nodes appear only after a stable ComfyUI release.
2. **You are signed in to a Comfy account.** Open Settings (the gear icon, or `Ctrl + ,`) and go to `User`. Email, Google and GitHub sign-in are supported.
3. **Your credit balance is above zero.** After signing in, `Settings → Credits` appears. Set an amount, click `Buy`, and pay through Stripe.
4. **Partner Nodes are enabled.** If ComfyUI was launched with `--disable-api-nodes`, every Partner Node is switched off. Remove the flag and restart.

![Diagram of a ComfyUI prompt going through a Partner Node to remote servers with a Comfy account and credits, the result returning to Save Image, and no local model checkpoint](https://blog.laozhang.ai/posts/en/gpt-image-2-5-comfyui/img/remote-generation.webp)

### Which sign-in fits your setup

The login rules depend on how you reach ComfyUI, not on which model you run. Direct sign-in only works when the browser runs on the same computer as ComfyUI and opens the local address ComfyUI prints in its terminal at startup. Reaching it through a network IP, a `--listen` setup or a server needs a key.

| How you reach ComfyUI | What to use | Where it comes from |
| --- | --- | --- |
| Browser on the same computer, at the local address ComfyUI prints at startup | Normal sign-in under `Settings → User` | Your Comfy account |
| Another device on your network (ComfyUI started with `--listen`), a remote server, or a host that isn't on Comfy's allowlist | The API Key option in the same sign-in dialog, with a **ComfyUI Account API Key**; serve ComfyUI over https | Created at platform.comfy.org |
| A script or automation tool sending the graph to the ComfyUI server's `/prompt` endpoint | The same ComfyUI Account API Key, passed as `extra_data.api_key_comfy_org` | Created at platform.comfy.org |
| Your own code, with no ComfyUI involved | A **Comfy Router** key, exported as `COMFY_API_KEY` | Created in your Comfy workspace at platform.comfy.org |
| An OpenAI key, another provider's key, or a ChatGPT plan | Not accepted by the node | — |

Two keys get confused here. The ComfyUI Account API Key is not the Registry publishing key that custom-node authors use. And although both the Account API Key and the Router key are created on platform.comfy.org, Comfy's documentation doesn't say one can stand in for the other, so create the key that matches the path you're using.

## Generate and save one image

1. **Load a template or add the node.** In the Template Library, search "GPT Image 2.5 Flare" or "GPT Image 2.5 Sunburst." There are four official templates: Flare Text to Image, Flare Image Edit, Sunburst Text to Image and Sunburst Image Edit. To build your own graph instead, search the Node Library for **OpenAI GPT Image 2.5**.
2. **Check the `model` field.** The node's dropdown holds five models: `gpt-image-2.5-flare`, `gpt-image-2.5-sunburst`, `gpt-image-2`, `gpt-image-1.5` and `gpt-image-1`. A node titled GPT Image 2.5 can still be set to an older model, so confirm it reads `gpt-image-2.5-flare` or `gpt-image-2.5-sunburst`.
3. **Write the prompt.** If the image needs text, put the exact words in quotes and say where they go. Ending the prompt with a short list of things to leave out keeps posters clean.
4. **Pick a size preset and leave quality at `low`.** The node defaults to `low`, which is the cheapest way to check the composition.
5. **Connect the `IMAGE` output to `Save Image` and run.** The file lands in ComfyUI's output folder like any other render.
6. **Check the debit.** `Settings → Credits` shows your balance and a Credit History entry for the run.

The node's settings, as the official guide and the node's source code define them:

| Setting | Values | What to know |
| --- | --- | --- |
| `size` | `auto`, presets from `1024x1024` to `3840x2160` / `2160x3840`, or `Custom` | Presets give an exact price on the badge; `auto` and `Custom` show a range |
| `custom_width` / `custom_height` | 480–3840, in steps of 16 | Only used when `size` is `Custom`; the pair must also pass the size rules below |
| `background` | `auto`, `opaque`, `transparent` | Both 2.5 models can return a transparent background for compositing |
| `quality` | `low`, `medium`, `high`, `xhigh`, `max` | Default `low`; `xhigh` and `max` exist only for the two 2.5 models |
| `images` | Up to 16 reference images | Connecting any image turns the run into an edit |
| `mask` | Optional | White areas get replaced; needs exactly one reference image |
| `n` | 1–8 | Multiplies the cost |
| `seed` | Any integer | Not used by the backend yet, so the same seed won't reproduce an image |

## What one run costs

Before each run, the node shows an approximate price in US dollars. Flare and Sunburst carry exactly the same badge at every size and quality:

| Size | `low` | `medium` | `high` | `xhigh` | `max` |
| --- | --- | --- | --- | --- | --- |
| 1024×1024 | $0.0084 | $0.0188 | $0.0753 | $0.1339 | $0.3013 |
| 1024×1536 or 1536×1024 | $0.0068 | $0.0147 | $0.0589 | $0.1055 | $0.2354 |
| 2048×2048 | $0.0170 | $0.0383 | $0.1531 | $0.2721 | $0.6123 |
| 3840×2160 or 2160×3840 | $0.0159 | $0.0371 | $0.1431 | $0.2544 | $0.5724 |

These are the badge values for one output image with no reference images connected. Three things change the number:

- **Each connected reference image** adds $0.0117–$0.0176.
- **`n`** multiplies the total, and the badge then shows a per-run figure.
- **`auto` or `Custom` size** turns the badge into a range, because the badge only has fixed prices for the presets. At `high` the range is $0.0222–$0.2544; at `max` it is $0.0887–$1.0175. Choose a preset when you want a single number.

The badge prices 3840×2160 slightly below 2048×2048 at every quality. That comes from the badge table itself, which is another reason to treat it as an estimate.

### How the actual debit is calculated

The real charge is worked out after the run from token usage. Comfy's rate for both 2.5 models is 9,051.9 credits per million output image tokens, 2,413.84 per million input image tokens, and 1,508.65 per million input text tokens. Comfy's pricing page says a 1024×1024 image at `low` produces about 196 output tokens, so the output alone costs 196 × 9,051.9 ÷ 1,000,000 ≈ 1.77 credits. The same page quotes "roughly 1.86 credits," which likely includes the prompt text.

Comfy doesn't publish a dollar value for a credit. Its own figures imply about 211 credits per dollar: 1.77 credits ÷ 211 ≈ $0.0084, which is exactly the badge price. That conversion is an estimate derived from Comfy's numbers, not an official rate. Applied to the output rate, it gives 9,051.9 ÷ 211 ≈ $42.90 per million output tokens, compared with the $30 per million OpenAI lists for direct API use. That's roughly 1.43 times the direct rate, again a calculation rather than a published markup.

### A sample session

Say you explore a poster with 10 Flare drafts at 1024×1024 `low`, then render two finals with Sunburst at 2048×2048 `high`:

- Drafts: 10 × $0.0084 = $0.084
- Finals: 2 × $0.1531 = $0.3062
- Total: about $0.39

If every one of those 12 runs also used one reference image, add 12 × ($0.0117 to $0.0176) = $0.14 to $0.21, for a total of about $0.53–$0.60. Switch the finals to `max` and they alone come to 2 × $0.6123 = $1.22.

### Credit rules worth knowing before you top up

- Credits are prepaid and non-refundable.
- One expensive run can push your balance below zero. Partner Nodes then stay blocked until a top-up brings it back above zero.
- Monthly plan credits expire at the end of the billing period; top-up credits expire one year after purchase.
- Credits can't be transferred to another user, but the same account works on any number of devices.
- On Comfy Cloud, Partner Nodes draw from the same credit pool as your subscription, so there is no separate bill.

## Flare or Sunburst, and which quality

Price doesn't decide between them in ComfyUI, because the badge is identical. The difference is what each model is tuned for. Flare is the fast one, meant for drafts, mood boards and trying several edits. Sunburst is the high-fidelity one: it holds on to a subject's identity, materials, lighting and scene structure across edits, which matters for product shots and multi-step edit chains.

Comfy's template notes suggest a working order that also keeps costs down:

1. Iterate in Flare at `low` until the composition and prompt are right.
2. Rerun the winning prompt in Sunburst.
3. Raise quality only for that final pass. Sunburst's fidelity advantage shows at `high` and above.

Quality is where the money goes. At 1024×1024, `high` costs about nine times `low`, and `max` costs four times `high`. Try `high` and `xhigh` before assuming a final needs `max`.

For a closer look at speed and editing behavior, see [GPT Image 2.5 Sunburst vs Flare: Which to Use, by the Numbers](https://blog.laozhang.ai/en/posts/gpt-image-2-5-sunburst-vs-flare). If your existing graph uses `gpt-image-2` and you're deciding whether to switch, [GPT Image 2.5 Flare vs Sunburst vs GPT Image 2: Which to Run](https://blog.laozhang.ai/en/posts/gpt-image-2-5-vs-gpt-image-2) compares the three. Note that `gpt-image-2` in the same dropdown tops out at `high`.

## Edit with reference images, then add a mask

Connect a `Load Image` node to the `images` input, and the run becomes an edit: the node calls OpenAI's edit endpoint instead of the generation endpoint, and your prompt becomes the edit instruction. You can connect up to 16 references. Before upload, each one is scaled down to at most 2048×2048 worth of pixels (about 4.2 megapixels), so a larger source photo adds upload time, not detail.

Edits work better when the prompt names what to keep before it names the change. Comfy's edit templates open by listing what must stay unchanged, such as the background, face, pose and lighting, and only then describe a single change. Run several edits in sequence rather than packing unrelated changes into one prompt.

For inpainting, connect a mask as well. Three rules apply, and the node enforces them with errors:

- **White means replace.** The white area of the ComfyUI mask is what the model redraws; black is what it should leave alone.
- **Exactly one reference image.** A mask with two or more references fails with `Cannot use a mask with multiple image`. A mask with no reference fails with `Cannot use a mask without an input image`.
- **Same width and height as the reference.** Otherwise the run stops with `Mask and Image must be the same size`.

The easiest way to satisfy the last rule is to paint the mask on the same `Load Image` node that feeds the reference and connect its `MASK` output. If you resize or crop the image between `Load Image` and the GPT Image node, apply the same resize to the mask.

![A red backpack reference, a mask with the front panel painted white, and the requested edit in which only the front panel turns navy](https://blog.laozhang.ai/posts/en/gpt-image-2-5-comfyui/img/reference-and-mask.webp)

A mask guides the edit; it is not a pixel lock. Compare the areas outside the mask with the original before you ship the result. With `n` above 1, the node returns the images as one batch, resizing any that come back at a different size to match the first.

## Custom sizes: the four rules

When `size` is `Custom`, the width and height widgets each accept 480–3840 in steps of 16, but the pair must also pass four checks when the run starts:

1. Both sides are multiples of 16.
2. The longest side is at most 3840.
3. The long side is no more than three times the short side.
4. Width × height is between 655,360 and 8,294,400 pixels.

That last rule catches values that look fine one at a time:

| Width × height | Pixels | Result |
| --- | --- | --- |
| 1024×1024 | 1,048,576 | Valid |
| 3840×2160 | 8,294,400 | Valid, exactly the ceiling |
| 3840×1280 | 4,915,200 | Valid, exactly 3:1 |
| 3840×1152 | 4,423,680 | Fails: ratio is about 3.3:1 |
| 3840×3840 | 14,745,600 | Fails: about 1.78 times the ceiling |
| 800×800 | 640,000 | Fails: under the floor |
| 480×480 | 230,400 | Fails: under the floor, even though 480 is the widget minimum |
| 816×816 | 665,856 | Valid, the smallest square that passes |

The error text names the broken rule, for example `Custom resolution total pixels must be between 655,360 and 8,294,400`.

## Fix a failed run by symptom

| What you see | Likely cause | What to do |
| --- | --- | --- |
| No GPT Image 2.5 templates, or the node isn't in the Node Library | ComfyUI older than 0.35.0; on Comfy Cloud, the stable release hasn't shipped yet | Update ComfyUI. If it's current and the node is still missing, check the startup log for nodes that failed to import |
| An older workflow uses a node called **OpenAI GPT Image 2** | That node is deprecated | Replace it with **OpenAI GPT Image 2.5** and set `model` |
| Sign-in fails, or ComfyUI keeps asking you to log in | ComfyUI is opened from another device or a server rather than through its local address on the same computer, for example with `--listen` | Log in with a ComfyUI Account API Key and serve ComfyUI over https |
| The node ran before, and now it won't | Balance is at or below zero, possibly after one expensive run | Top up under `Settings → Credits` until the balance is positive |
| Every Partner Node has disappeared | ComfyUI was launched with `--disable-api-nodes` | Remove the flag and restart |
| `Custom resolution ...` error | The width/height pair breaks one of the four size rules | Use the table above, or pick a preset |
| `Cannot use a mask with multiple image` | More than one reference connected with a mask | Keep one reference for masked edits |
| `Mask and Image must be the same size` | Mask dimensions differ from the reference | Paint the mask on the same `Load Image` node, or resize both together |
| `Cannot use a mask without an input image` | A mask is connected but no reference image is | Connect the image the mask belongs to |
| `xhigh` and `max` aren't in the quality list | `model` is set to `gpt-image-2` or older | Switch `model` to a 2.5 model |
| Same seed, different image | The backend ignores `seed` | Save the outputs you like instead of relying on the seed |
| The provider refuses a prompt | OpenAI applies its own content moderation | Rephrase; don't send prohibited content to Partner Nodes |

If the run succeeds but the image looks noisy, check the quality level first, since the node starts at `low`. [GPT Image 2.5 Grainy Noise: Fixes for ChatGPT and the API](https://blog.laozhang.ai/en/posts/gpt-image-2-5-noise-grainy) covers the other causes.

## Run the same graph from a script, or skip ComfyUI

### Queue the graph without the browser

A graph containing Partner Nodes can run headless: export the workflow in API format, then send it to the ComfyUI server's `/prompt` endpoint with your ComfyUI Account API Key in `extra_data`. Credits are charged as usual.

```python
import json
import os
from urllib import request

# Workflow saved from ComfyUI in API format, containing the
# OpenAI GPT Image 2.5 node and a Save Image node
with open("gpt_image_25_api.json") as f:
    workflow = json.load(f)

# The address after "To see the GUI go to:" in ComfyUI's startup log
COMFYUI_URL = os.environ["COMFYUI_URL"]

payload = {
    "prompt": workflow,
    "extra_data": {"api_key_comfy_org": os.environ["COMFYUI_ACCOUNT_API_KEY"]},
}

req = request.Request(
    f"{COMFYUI_URL}/prompt",
    data=json.dumps(payload).encode("utf-8"),
    headers={"Content-Type": "application/json"},
)
print(request.urlopen(req).read().decode())
```

The server queues the graph, and `Save Image` writes the result to the output folder as it would from the browser. Any tool that can send an HTTP POST, including n8n, can use the same payload. If you'd rather have n8n call the model directly without ComfyUI, see [GPT Image 2.5 in n8n: When the OpenAI Node Isn't Enough](https://blog.laozhang.ai/en/posts/gpt-image-2-5-n8n).

### Call the model from code with no ComfyUI

Comfy Router is a separate Comfy API for code that never opens a ComfyUI graph. It uses a Router key sent in the `X-API-Key` header:

```bash
curl https://api.comfy.org/v2/models/openai/gpt-image-2.5-flare \
  -H "X-API-Key: $COMFY_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a rocketship on a launchpad", "quality": "low", "size": "1024x1024"}'
```

Swap `flare` for `sunburst` in the URL to use the other model. Comfy also ships SDKs (`pip install comfy-sdk`, `npm install @comfyorg/sdk`). Router charges when the provider bills Comfy, and the place to reconcile charges is your workspace usage on platform.comfy.org, not the ComfyUI Credit History.

Outside Comfy entirely, the model is available from OpenAI's API at $30 per million output tokens, and from resellers such as [LaoZhang API](https://docs.laozhang.ai/en/api-capabilities/gpt-image-2-5). LaoZhang offers `gpt-image-2.5-flare` and `gpt-image-2.5-sunburst` at OpenAI's token price, plus `-vip` variants at $0.03 per call, available again since September 22, 2026; the `-vip` models don't accept a mask. [GPT Image 2.5 Sunburst Pricing: Official Costs vs $0.03 per Call](https://blog.laozhang.ai/en/posts/gpt-image-2-5-api-pricing) compares those routes. None of these keys works inside the ComfyUI node, which only accepts Comfy credentials.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

## FAQ

### Is there a GPT Image 2.5 model to download for ComfyUI?

No. The model runs on OpenAI's servers, and ComfyUI only sends the request. What you can download are the template workflows: JSON graphs in Comfy's `workflow_templates` repository on GitHub, also available in the Template Library. Third-party custom nodes that wrap GPT Image 2.5 also exist, but they have their own credentials and billing and aren't the official node.

### Can I use my OpenAI API key or ChatGPT Plus in the ComfyUI node?

No. The official node authenticates only with your Comfy account or a ComfyUI Account API Key, and Comfy lists bringing your own API key as not supported yet. A ChatGPT plan covers image generation inside ChatGPT; [ChatGPT Images 2.5: How to Use It in ChatGPT and the API](https://blog.laozhang.ai/en/posts/chatgpt-images-2-5) explains that route.

### Is GPT Image 2.5 free in ComfyUI?

No. ComfyUI itself stays free and open source, but every Partner Node run spends credits, and the node won't run with a balance at or below zero. A single 1024×1024 image at `low` quality costs about $0.0084 on the badge.

### Does Comfy Cloud need separate credits for GPT Image 2.5?

No. On Comfy Cloud, Partner Nodes use the same credit pool as your subscription. Cloud gets new nodes after each stable ComfyUI release, so a node that just shipped for local installs can arrive on Cloud a little later.

### Why does the node work on my PC but not from my laptop on the same network?

Direct sign-in only works in a browser on the same computer as ComfyUI, opened at the local address ComfyUI prints at startup. When you open ComfyUI from another device, for example after starting it with `--listen`, sign in with a ComfyUI Account API Key instead, and serve it over https.