# Image models compared: GPT Image 2, Nano Banana, FLUX.2

URL: https://infro.io/blog/ai-image-models-compared-2026
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-09-29
Last modified: 2026-09-29
Last reviewed: 2026-09-29 (next review due 2026-10-29)
Topic: Agents and multimodal systems
Format: Comparison

> Image generation APIs differ less in headline price than in how they bill (tokens, images or megapixels), which sizes and references they accept, how long results stay downloadable, and when they retire. Compare those documented facts, then measure cost per accepted image on your own prompts.

Two widely used image models left their vendors' APIs this year, and a third family has a date. Google's Imagen page now says plainly that the Imagen models are shut down and to use Nano Banana instead[1]; the deprecations table gives 17 August 2026 for Imagen 4 Standard, Ultra and Fast[2]. OpenAI has announced that `gpt-image-1.5`, `gpt-image-1-mini` and `chatgpt-image-latest` shut down on 1 December 2026[3].

That churn shapes how to compare image models. A ranking of which model draws best will be stale before a product ships on it. The facts that decide whether a model fits — how it bills, what it accepts, how you get results back and how long it will exist — are documented, and they are what this comparison covers.

## Three billing units, not one

The most common mistake in comparing image models is to put a per-image number beside a per-token number as if they measured the same thing. They do not.

[Diagram: How each vendor bills image generation, from its own pricing page on 2026-09-29. A per-token rate and a per-image rate are not directly comparable until you convert at the size and quality you use.]

**Per token — OpenAI GPT Image.** OpenAI's pricing page lists `gpt-image-2` at $8 per 1M image input tokens, $5 per 1M text input tokens and $30 per 1M image output tokens[4]. The newer `gpt-image-2.5-sunburst` lists the same image output rate of $30 per 1M, plus cached-input rates, and does not bill text output because it only returns images[5]. What an image costs therefore depends on how many output tokens it takes, which rises with quality and size.

**Per image, by resolution — Google Nano Banana.** Google lists Nano Banana 2 (`gemini-3.1-flash-image`) at $0.045 for a 0.5K image, $0.067 at 1K, $0.101 at 2K and $0.151 at 4K. Nano Banana Pro (`gemini-3-pro-image`) is $0.134 at 1K or 2K and $0.24 at 4K[6].

**Per megapixel — Black Forest Labs FLUX.2.** BFL prices by output megapixels, so larger images cost more. FLUX.2 [pro] starts from $0.03 for text-to-image and $0.045 for editing, [flex] from $0.05, [max] from $0.07, and the [klein] models from $0.014; [dev] is listed as local only[7].

**Per image, by variant — xAI Grok Imagine.** xAI lists `grok-imagine-image` at $0.02, `grok-imagine-image-2.0` at $0.04 and `grok-imagine-image-quality` at $0.05 per image[8].

> **Example: Converting to cost per accepted image**
> Suppose a marketing tool needs 2K images and users keep one image in four. On Nano Banana 2 at $0.101 per 2K image, the cost per kept image is about $0.40 at list rate. On a token-priced model, generate the same 50 test prompts at your chosen size and quality, read the output token counts from the provider's usage data, and divide the total by the images kept. The comparison that matters is cost per accepted image at your settings, not the smallest number on a pricing page.

## What each API accepts

Sizes, references and editing features vary more than prices do, and they decide whether a model can do the job at all.

|  | GPT Image (OpenAI) | Nano Banana 2 | Nano Banana Pro | FLUX.2 (BFL) |
| --- | --- | --- | --- | --- |
| Sizes | Three recommended sizes; custom sizes in multiples of 16, ratio 1:3 to 3:1, edge up to 3,840 px[9] | 0.5K, 1K, 2K, 4K; ten aspect ratios[10] | 1K, 2K, 4K[10] | Priced by megapixel[7] |
| Reference images | Image inputs for editing, masks with alpha[9] | Up to 10 object, 4 character, 3 style[10] | Up to 6 object, 5 character, 3 style[10] | Editing priced separately[7] |
| Quality control | `low` to `max`, plus `auto`[9] | Resolution | Resolution | Model tier |
| Transparent output | Yes, PNG or WebP[9] | Not stated | Not stated | Not stated |
| Watermark | Not stated | SynthID[10] | SynthID[10] | Not stated |

Table: Documented capabilities on 2026-09-29. "Not stated" means the page opened for this article did not say.

Two notes. OpenAI says resolutions above 2560×1440 are experimental and that complex prompts can take up to two minutes[9] — relevant if you planned to hold a user request open. And Google documents text rendering and search grounding for its Nano Banana models, with grounding unavailable on the Lite variant[10]; if your images must contain accurate text, test that specifically.

## How results come back, and how long they last

Image generation is often called synchronous, but not every vendor's native API is. BFL's API answers a submit with an `id` and a `polling_url`; you poll until the status is `Ready`, and the signed result URL in `result.sample` is valid for 10 minutes only[11]. BFL also offers global, EU-only and US-only endpoints, which matters if your images must stay in a region[11]. OpenAI can stream up to three partial images while a render is in progress[9].

The practical rule is the same as for video: treat any provider URL as a short-lived handoff and copy the bytes to your own storage as part of the request that produced them.

## Retirements are part of the comparison

[Diagram: Image model shutdown dates from Google's and OpenAI's deprecation pages, read 2026-09-29.]

Google also lists `gemini-2.5-flash-image` — the original Nano Banana — with a 2 October 2026 shutdown date[2]. OpenAI's replacements for the GPT Image 1.x family are the GPT Image 2.5 models[3]. If you pick a model today, look up its vendor's deprecation page as part of the decision, and prefer a model that is generally available over a preview when you need it for longer than a few months.

## A method for choosing

1. **Write down hard constraints**: output size, aspect ratio, transparency, text-in-image, reference images, region.
2. **Assemble 50 real prompts**, including edits, text rendering and prompts that must be refused.
3. **Generate on two or three candidates** at the size and quality you will actually use, and let the people who own the output choose blind.
4. **Compute cost per accepted image** from the vendor's billing unit and your acceptance rate.
5. **Check lifecycle**: deprecation status, notice policy and whether a replacement is named.
6. **Qualify a fallback** on the same prompts, so a retirement or an outage is a configuration change.

## Serving image models through INFRO

INFRO serves images through `POST /v1/images/generations` and `POST /v1/images/edits`, synchronously: the request stays open while your provider renders, and the response carries the images. `model` is a catalog id such as `bfl/flux-2-pro` or the slug of one of your routes; `size` must have the `WIDTHxHEIGHT` shape and is passed to your provider unchanged, so a provider that cannot render it picks its nearest size or refuses, by its own rules. `quality` and `seed` are forwarded on generations only. See [image generation](https://infro.io/docs/modalities/images).

[Diagram: An image request through INFRO. Every step is documented in the image generation reference.]

Image requests are served by connections whose provider kind handles images through OpenAI's images API: OpenAI, Azure OpenAI, Together, OpenRouter and OpenAI-compatible endpoints. A model that its vendor offers only through a native API — Gemini's image models, for instance — is reachable only where one of those providers exposes it, so check your provider's model list before planning on it.

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://api.infro.io/v1", api_key=os.environ["INFRO_API_KEY"])

image = client.images.generate(
    model="bfl/flux-2-pro",
    prompt="An isometric cutaway of a small data center, soft studio lighting",
    size="1024x1024",
    n=1,
    extra_body={"fallbacks": ["bfl/flux-2-dev"]},
)

# The URL points at a copy INFRO keeps for 24 hours. Store the bytes yourself.
print(image.data[0].url)
```

If a connection errors before producing an image, INFRO tries the next target on the route and then each model in `fallbacks`, which must be image models too. The response names the `provider`, `connection` and `route` that served it, and `usage.cost` estimates what your provider will bill, counting only the images that came back; `usage.price_source` says whether that estimate used the vendor's list rate or a rate you entered. For a token-priced model, reconcile that estimate against your provider's own usage data. A request that would exceed a budget you set is refused with `402 budget_exceeded` before any provider is called. The `data[].url` link expires 24 hours after the request, the same retention as [async job outputs](https://infro.io/docs/api/jobs).

Edits go to `/v1/images/edits` as multipart form data: the image and an optional mask, each PNG, JPEG or WebP up to 25 MB, in a request body of up to 51 MB. `quality` and `seed` are accepted there but not forwarded, and which dimensions and aspect ratios an edit accepts is your provider's decision. On OpenAI's API the mask is a PNG with an alpha channel the same size as the image, and transparent pixels mark the region to repaint. Because editing behaviour differs more between vendors than generation does, qualify any fallback for edits separately rather than assuming a model that generates well also edits the way your product expects.

## Questions

### Is Imagen 4 still available in the Gemini API?

No. Google's Imagen page says the Imagen models are shut down, and the deprecations page lists 17 August 2026 for all three Imagen 4 models, with gemini-3.1-flash-image as the replacement.

### Why does the same image cost different amounts on the same model?

Most image APIs price by output size or quality. Google prices Nano Banana 2 by resolution, BFL prices FLUX.2 by megapixel, and OpenAI bills GPT Image by tokens, which grow with quality and size.

## Sources

1. Imagen — Google. https://ai.google.dev/gemini-api/docs/imagen (accessed 2026-09-29)
2. Gemini deprecations — Google. https://ai.google.dev/gemini-api/docs/deprecations (accessed 2026-09-29)
3. Deprecations — OpenAI. https://developers.openai.com/api/docs/deprecations (accessed 2026-09-29)
4. Pricing — OpenAI. https://developers.openai.com/api/docs/pricing (accessed 2026-09-29)
5. GPT Image 2.5 Sunburst model page — OpenAI. https://developers.openai.com/api/docs/models/gpt-image-2.5-sunburst (accessed 2026-09-29)
6. Gemini Developer API pricing — Google. https://ai.google.dev/gemini-api/docs/pricing (accessed 2026-09-29)
7. Pricing — Black Forest Labs. https://docs.bfl.ai/quick_start/pricing (accessed 2026-09-29)
8. Models and pricing — xAI. https://docs.x.ai/docs/models (accessed 2026-09-29)
9. Image generation — OpenAI. https://developers.openai.com/api/docs/guides/image-generation (accessed 2026-09-29)
10. Image generation with Gemini (Nano Banana) — Google. https://ai.google.dev/gemini-api/docs/image-generation (accessed 2026-09-29)
11. Generating images — Black Forest Labs. https://docs.bfl.ai/quick_start/generating_images (accessed 2026-09-29)