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

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.

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.

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:

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:

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. 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 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 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:

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

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 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.

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.

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:

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. 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 compares those routes. None of these keys works inside the ComfyUI node, which only accepts Comfy credentials.

Disclosure: laozhang.ai is our own service. 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 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.