Nano Banana 2.1 pricing: what an image costs and how to estimate a job

As of October 13, 2026, Ofox’s public catalog lists google/gemini-nano-banana-2.1 at $1.50 per million input tokens, $7.50 per million text-output tokens, $30 per million image-output tokens, and $0.014 per web-search request. A tested 1K image used 1,120 image-output tokens, making its image component $0.0336 at the listed rate. That is not a fixed price for the whole request: input, text, potentially billed thinking, searches, retries, and subsequent edits can add to it.

Ofox publishes this article and is the gateway tested here. The prices below are a dated reading of its public catalog, not an invoice or a promise that a future request will be billed identically. The accompanying API checks used the Ofox gateway; the image responses and usage figures are observations from those checks.

The listed rates, without mixing their units

The exact Ofox model ID is google/gemini-nano-banana-2.1. Its public model page lists Gemini and OpenAI protocols and Vertex as provider. The catalog rates have different billing units:

The catalog’s provider price is null for this model. That does not establish a provider discount, a zero provider cost, or a second rate to substitute for the listed one. Likewise, the catalog type definitions distinguish an output_image per-token price from output_image_per_num, a separate per-image-count field. Do not turn the former into a flat per-image catalog price.

The rates were fetched from the public Ofox catalog on October 13, 2026. We also checked the catalog implementation and field definitions against dated repository revisions in our editorial audit. The catalog is dynamic: its implementation does not store a fixed price table in Git. input, output and output_image are per-token fields; web_search is per request. Implementation checks establish field meaning, not that the deployed service matches a particular repository revision or that an estimate equals your settled bill.

A measured first request—and an explicitly assumed total

Our first tested request was a 1:1, 1K poster generation through the Ofox native Gemini endpoint. It returned HTTP 200 with STOP, a 1024 × 1024 PNG, and reported 54 input tokens, 80 reported text-output tokens, 1,120 image-output tokens, and 639 thought tokens. The actual content contained only an image part, with no visible text part; these 80 tokens are a usage-metadata report, not a count of visible prose. The image-output component is straightforward:

1,120 image-output tokens × ($30 / 1,000,000 tokens) = $0.033600
54 input tokens         × ($1.50 / 1,000,000 tokens) = $0.000081
80 reported text tokens  × ($7.50 / 1,000,000 tokens) = $0.000600
                                                Subtotal = $0.034281

If—and this is an assumption for estimating, not a verified invoice calculation—all 639 reported thought tokens are charged at the same $7.50-per-million text-and-thinking rate, they add:

639 × $7.50 / 1,000,000 = $0.0047925
Assumed estimate for this request = $0.034281 + $0.0047925
                                  = $0.0390735

That estimate excludes any applicable charge not established by this request and should not be presented as the amount Ofox billed. It also shows why “1K costs 3.36 cents” needs qualification: 3.36 cents is the image component in this measured case.

To inspect your own response instead of relying on a flat-price assumption, this request uses the exact first prompt from the check. It saves the full response so that usage and image parts can be examined separately:

cat > request.json <<'JSON'
{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "Create a square minimalist event poster on warm cream paper. Large exact headline: ORCHARD MARKET. Smaller exact line: SATURDAY 10 AM. Draw three red apples in a blue ceramic bowl below the text. No other text, no logos, no border."
    }]
  }],
  "generationConfig": {
    "responseModalities": ["TEXT", "IMAGE"],
    "imageConfig": {"aspectRatio": "1:1", "imageSize": "1K"}
  }
}
JSON

curl --fail-with-body \
  -H "x-goog-api-key: $OFOX_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @request.json \
  "https://api.ofox.ai/gemini/v1beta/models/google/gemini-nano-banana-2.1:generateContent" \
  > response.json

python3 - <<'PY'
import base64
import json

with open("response.json", encoding="utf-8") as f:
    response = json.load(f)

print(json.dumps(response.get("usageMetadata", {}), indent=2))
for candidate_index, candidate in enumerate(response.get("candidates", [])):
    for part_index, part in enumerate(candidate.get("content", {}).get("parts", [])):
        inline = part.get("inlineData")
        mime = (inline or {}).get("mimeType", "")
        if inline and inline.get("data") and mime.startswith("image/"):
            extension = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp"}.get(mime)
            if extension is None:
                raise ValueError("Unsupported image MIME type: " + mime)
            name = f"image-{candidate_index}-{part_index}{extension}"
            with open(name, "wb") as f:
                f.write(base64.b64decode(inline["data"], validate=True))
            print("Saved", name, inline.get("mimeType"))
        elif "text" in part:
            print("Text part:", part["text"])
PY

Set OFOX_API_KEY in your environment first. The code saves every returned inline image part, rather than treating a text part as an image. The filename extension follows the returned MIME type; an unsupported type stops extraction rather than being mislabeled as PNG. Keep the full JSON if continuing the conversation: in our multi-turn checks, each previous candidates[0].content was sent back intact, including any thought-signature parts, followed by a new user turn. Rebuilding that content from extracted text and images is not equivalent. For request setup and response handling beyond this price example, see the Nano Banana 2.1 API guide.

Resolution changes the image component

Google’s official pricing supplies token counts and image-price examples; its model documentation describes resolution capabilities. The table separates what we actually received through Ofox from what is documented elsewhere:

There is a material 4K documentation conflict: Google’s image-generation documentation also gives 2,520 image tokens in its image-generation table. At $30 per million, 2,520 would produce a $0.0756 image component, rather than $0.1134. The conflicting figures should not be silently averaged or turned into a promised Ofox 4K quote. Check the current documentation, the catalog, and an actual 4K response and bill before budgeting 4K at either figure. The listed 1K and documented 2K figures still omit the other components of a request.

Budgeting accepted images, retries, and edits

For a batch, count generated outputs, not just images you ultimately keep. Using the observed 1,120-token 1K image component as a hypothetical constant:

100 generated 1K outputs × $0.0336 = $3.36 image component
125 generated 1K outputs × $0.0336 = $4.20 image component

The second line describes a hypothetical job that generates 125 images to accept 100—an 80% acceptance rate. It is not a measured acceptance rate or a prediction. Both sums exclude input, text, thinking, searches if applicable, and other possible charges. Multiple candidates, reruns after an unsuitable result, and edit attempts all matter because a generated but rejected image was still generated.

An edit chain adds another complication: later requests submit previous conversation content and an image, so input usage can grow. Our single three-step 2.1 chain used the following exact follow-ups:

“Change only the headline from ORCHARD MARKET to ORCHARD FAIR. Keep SATURDAY 10 AM exactly unchanged. Preserve the three red apples, blue bowl, cream background, composition and all other pixels as closely as possible.”

“Now change only the bowl from blue to dark green. Preserve ORCHARD FAIR, SATURDAY 10 AM, the three red apples and the layout.”

The three image components alone total $0.1008. Reported input components total $0.0052395, before output-text or thinking assumptions. The first turn reported 80 text-output tokens and 639 thought tokens; the second reported no TEXT output category and 358 thought tokens; the third reported no TEXT output category and did not report thoughts. “Not reported” must not be converted into “zero billed.” Nor does the returned usage explain every detail of how the submitted history was accounted for. This is why adding a simple three-image estimate to a quote for an editing workflow is unsafe without checking actual usage and billing. The poster-editing walkthrough focuses on what the edits did visually rather than treating preservation instructions as a pixel-level guarantee.

Is 2.1 cheaper than Nano Banana 2?

It depends on which price component you mean. The older model’s exact Ofox ID is google/gemini-3.1-flash-image. In the dated catalog snapshot, its listed rates were $0.50/M input, $3/M text output, and $60/M image output. For the same 1,120 image-output tokens, the listed image component would be:

Nano Banana 2:   1,120 × $60 / 1,000,000 = $0.0672
Nano Banana 2.1: 1,120 × $30 / 1,000,000 = $0.0336

Thus 2.1’s listed image-token rate is half the older model’s. Its listed input rate is three times as high, however, and its text-output rate is 2.5 times as high. It would be incorrect to advertise a blanket “50% off” total request or workflow cost.

We also ran one corresponding three-step chain on the older model. Both models’ six requests returned HTTP 200 with STOP and one 1024 × 1024 PNG per turn. The observed prompts and image-output token counts aligned for this narrow comparison, but the models may have used different defaults; no seed or thinking level was set, and there were no repetitions. The older model did not report thought tokens on these runs, which is not proof that thinking cost was zero. See the 2.1-versus-2 comparison for the visual limits of that test, not a general quality or total-cost ranking.

What to check before committing a budget

Refresh the live Ofox catalog and model page immediately before a substantial run; a dated snapshot can become stale, and Git implementation links do not freeze dynamic prices. Record the model ID, requested resolution, response usage, number of generated images, and invoice or account billing data. Separate observed billing from calculations based on listed rates. If a request returns text only, an error, or no usable image, do not assume it is free: inspect its usage and billing outcome. The no-image troubleshooting guide covers response-part and failure checks.

Finally, keep capability and cost claims separate. Google documents up to 14 references and 1K, 2K, and 4K capabilities, but this check did not exercise all of them through the Ofox route. The public Ofox model-page interface is evidence of listing and preparation, not an API-generated result; its embedded Playground required login, and authenticated Agent model selection was not tested. No conclusion here depends on an Agent definitely selecting 2.1.

This article was AI-assisted, checked against the stated API responses and source chain, and independently AI-reviewed before publication. The most defensible working estimate remains $0.0336 for the image-output component of the observed 1K generation, plus separately estimated and then verified charges for everything the actual request used.