Nano Banana Pro currently costs $0.134 per 1K/2K image on Google’s official standard API route, while 4K costs $0.24. Batch and Flex cut those official image rates in half to $0.067 and $0.12.
That is the useful first answer. The next decision is which pricing lane you are actually looking at. Google’s per-image API pricing, Google’s consumer bundles, and cheaper non-official provider rates are different contracts. If you anchor on the official number first, the rest becomes much easier to compare. Those official rates and the current model mapping were checked against Google’s public docs on April 18, 2026.
Nano Banana Pro is the market-facing name most people search. In Google’s developer docs, the current model route is gemini-3-pro-image-preview. On Vertex AI, you will see the same family surfaced as Gemini 3 Pro Image. The naming matters for setup, but it does not change the first answer: the current official price per image is still the number above.
Official Price Per Image Right Now
If you only need the current official number, this is the entire price ladder:
| Official route | Output size | Current price per image |
|---|---|---|
| Standard API | 1K / 2K | $0.134 |
| Standard API | 4K | $0.24 |
| Batch / Flex | 1K / 2K | $0.067 |
| Batch / Flex | 4K | $0.12 |
The line that confuses many readers is the shared 1K / 2K row. Google’s current pricing page does not split those into separate image-output prices for this model. The next jump only happens when you move to 4K.
If you are budgeting a workflow, the math is straightforward:
- 100 standard 1K/2K images cost $13.40
- 100 standard 4K images cost $24.00
- 100 Batch/Flex 1K/2K images cost $6.70
- 100 Batch/Flex 4K images cost $12.00
So the real first split is not “free plan or paid plan.” It is “standard official pricing or discounted official pricing.” Everything else belongs to a different lane.
Same Model, Two Official Routes
If you are choosing between Google’s own official routes, the model is the same but the operating context is different.
Use Gemini Developer API / AI Studio when you want the fastest path to a working integration. It is the simpler route for prototypes, prompt iteration, and smaller production workloads. You authenticate with an API key, the docs are narrower, and most readers who only need image generation should start here.
Use Vertex AI when the real job is cloud governance, project-level IAM, enterprise controls, or broader Google Cloud operations. You are still buying the same model family, but you are choosing a different runtime and operational environment.
The important correction is this: do not invent a price difference between the two official routes unless Google explicitly documents one. For this topic, the useful distinction is workflow fit, not a made-up “AI Studio is cheaper” shortcut.
If you want the practical setup path after pricing, see the Nano Banana Pro API guide.
Consumer Plans Are A Different Pricing Lane
If your real question is “what do I pay inside Gemini, AI Mode, or Flow?”, you are no longer looking at the per-image API contract. You are looking at a bundle-and-credit contract.
On the U.S. public purchase pages checked on April 18, 2026, Google showed:
- Premium (2 TB) at $9.99/month with 200 monthly AI credits
- Google AI Pro (5 TB) at $19.99/month with 1000 monthly AI credits
Those numbers matter if you plan to work inside Google’s consumer tools. They do not replace the official API price rows above, and they should not be used as if Google had published one universal “subscription price per image.”
This is where many pricing pages drift off course. They flatten four separate questions into one article:
- What is the official API price per image?
- What changes on Batch/Flex?
- What do Google’s consumer bundles currently include?
- What are cheaper non-official providers quoting?
Those are related questions, but they are not the same contract.
Use consumer-plan math when:
- you create inside Gemini, AI Mode, or Flow
- you care more about bundled credits and tool access than raw API billing
- your route is a Google consumer surface rather than a developer integration
Do not use consumer-plan math when:
- you are budgeting API usage for a coded workflow
- you need a clean per-image rate for batch generation
- you are comparing Google’s official developer contract against a third-party provider
If your question is really about Gemini or Flow access limits, the better follow-up is Nano Banana Pro free vs Pro limits, not another plan matrix pasted into an API pricing guide.
Batch and Flex: The Official Cheap Route
If latency is flexible and price matters most, Batch / Flex is the official cheap route.
The reason this matters is simple: many readers jump straight from “official Google API” to “cheaper third-party provider.” That skips the most important middle lane. Google already gives you an official discount path if you do not need immediate turnaround.
Here is the practical interpretation:
- choose standard pricing when users are waiting on the result, you need immediate generation, or the workflow is interactive
- choose Batch / Flex when you are generating scheduled assets, catalog images, backlogged marketing creative, or any queue where the job can finish later
At moderate volume, the savings add up quickly. A workflow that generates 1,000 1K/2K images costs $134 on standard pricing and $67 on Batch/Flex. At 4K, the same 1,000-image workload is $240 versus $120.
That is why Batch/Flex deserves its own section instead of being buried in a footnote. It is not a niche optimization. It is Google’s official answer for teams that care more about cost than immediacy.
Non-Official Providers And The Cheapest Legit Route
If you are tempted by a cheaper provider, that does not automatically mean the quote is fake. It does mean you are comparing a different provider contract, not disproving Google’s official price.
A lower outside rate can make sense when a provider:
- pools traffic differently
- flattens resolution pricing
- bundles multiple model routes behind one billing layer
- accepts tighter margins in exchange for volume
That can be rational. It can also be the cheapest legitimate route for some teams. But compare it honestly.
Ask these questions before treating a lower outside price as your real default:
- Is the provider clearly exposing the same model family and current route?
- Are the quoted limits, latency, safety behavior, and uptime good enough for your workload?
- Are you comfortable with the provider’s billing, support, and data-handling boundary?
- If something breaks, do you need first-party Google support or is a gateway-style contract acceptable?
So the clean rule is:
- if you want the official current number, use Google’s own price rows
- if you want the official cheaper lane, use Batch/Flex
- if you want the cheapest outside lane, compare non-official providers only after the official answer is anchored
That order matters because many pages reverse it and let the cheapest quote become the semantic owner of the article. For this topic, that produces more confusion than value.
Quick Decision Table
If you just want the practical route, use this table:
| Your job | Start here | Why |
|---|---|---|
| I need the current official Google price | Standard API pricing | It is the cleanest official per-image answer |
| I need the cheapest official route | Batch / Flex | Same model family, half the price, slower execution |
| I use Gemini or Flow rather than a coded API workflow | Consumer bundle pricing | You are paying through credits and plans, not per-image API rows |
| I need the cheapest external billing route | Non-official provider comparison | It may be cheaper, but it is a different provider contract |
| I need an official setup path for production | Gemini Developer API or Vertex AI | Same model, different operating environments |
The most common mistake is starting with the last two rows and then trying to backfill Google’s official number later. Reverse that order. Official price first, then contract choice.
FAQ
Why do 1K and 2K cost the same?
Because Google’s current public pricing for this model keeps 1K and 2K on the same image-output row. The next official jump is the 4K row.
Does 4K always cost more?
On the current official pricing surface for this model, yes. Standard 4K is $0.24 and Batch/Flex 4K is $0.12, both above the 1K/2K row.
Are Google consumer plans billed per image?
Not in the same way as the API. Consumer plans bundle access and credits, so they should be treated as a different pricing lane rather than a flat per-image API contract.
What changes on Batch/Flex?
The model family stays the same, but the price is cut in half and the operational trade-off is latency. Use it when you can queue work instead of waiting on every image in real time.
When is a cheaper provider actually a different contract?
As soon as the billing, support, rate limits, or operating boundary belong to the provider rather than to Google’s first-party route. The model may still be valid, but the contract is no longer the same one as Google’s official price page.