AIREITERThe same 1024x1024 image costs $0.003 from one API and over $0.10 from another. At 10,000 images per month, that gap turns a $30 bill into a $1,000 one. The catch: comparing prices directly is harder than it should be, because OpenAI bills per output token, Google bills per output token with a different tokenizer, and Black Forest Labs bills per megapixel.
This guide normalizes every major image API to one unit, cost per 1024x1024 image, so you can sort by actual spend.
Every Image API Price, Normalized to One 1024x1024 Image
Why Raw Prices Lie
Three billing models dominate AI image APIs, and none of them quote a clean per-image number on their pricing pages:
- Per output token (OpenAI, Google): The image is encoded as tokens. A 1024x1024 image from GPT Image 2 generates roughly 1,056 output tokens. At $30/M output tokens, that's about $0.032 per image. But the prompt tokens also cost money: a short text prompt adds ~$0.001 in input tokens. Scale to 4K resolution or add a reference image, and the token count (and cost) roughly quadruples.
- Per megapixel (Black Forest Labs): FLUX.2 Pro charges $0.03 for the first megapixel plus $0.015 per additional megapixel. A 1024x1024 image is ~1.05 MP, so you pay $0.03. A 2048x2048 image is ~4.2 MP, so you pay $0.03 + (3.2 x $0.015) = $0.078, nearly 3x the cost for 4x the pixels.
- Flat per-image (fal.ai, aggregators): Some providers charge a flat rate regardless of resolution, up to a cap. Simplest model, but usually not the cheapest at standard resolution.
A price labeled "$0.03" can mean wildly different things depending on what resolution you generate and which billing model the provider uses.
The Pricing Table
All prices below are for one 1024x1024 image. Token-based models are estimated using typical output token counts for that resolution. Prices verified against official documentation in the first week of August 2026.
| Model | Provider | ~Price/Image (1024x1024) | Billing Model | Free Tier |
|---|---|---|---|---|
| FLUX.2 [klein] 4B | Black Forest Labs | ~$0.003 | Per megapixel | No |
| FLUX.2 [klein] 9B | Black Forest Labs | ~$0.004 | Per megapixel | No |
| Seedream 5 Lite | ByteDance | ~$0.008 | Per image | No |
| Nano Banana 2 Lite | ~$0.010 | Per output token | Yes (limited) | |
| FLUX.2 [pro] | Black Forest Labs | ~$0.030 | Per megapixel | No |
| GPT Image 2 (standard) | OpenAI | ~$0.032 | Per output token | No |
| Nano Banana 2 | ~$0.035 | Per output token | Yes (limited) | |
| Seedream 5 Pro | ByteDance | ~$0.035 | Per image | No |
| Wan 2.7 Image Pro | Alibaba | ~$0.035 | Per image | No |
| FLUX.2 [max] | Black Forest Labs | ~$0.070 | Per megapixel | No |
| Nano Banana Pro | ~$0.080 | Per output token | Yes (limited) | |
| GPT Image 2 (high quality) | OpenAI | ~$0.095 | Per output token | No |
A few notes:
- GPT Image 2 pricing depends heavily on output quality. OpenAI's image output token rate is $30/M tokens. A standard-quality 1024x1024 image runs ~1,056 output tokens ($0.032). A high-quality render at the same resolution produces more tokens, pushing the cost past $0.09.
- Nano Banana 2 Lite uses the Gemini 3.1 Flash Lite backbone at $0.30/M input and $2.50/M output tokens. Image output tokens vary, but Google's documentation suggests roughly 4,000 output tokens for a generated image, landing around $0.010.
- Google's free tier covers Nano Banana models but caps you at ~15 RPM. Free-tier usage feeds Google's product improvement pipeline. The paid tier removes both constraints.
Monthly Cost at Scale: 1K, 10K, and 100K Images
A few cents per image don't matter at 100 images per month. At 100,000, they decide whether the project is viable.
| Model | 1K images/mo | 10K images/mo | 100K images/mo |
|---|---|---|---|
| FLUX.2 [klein] 4B | $3 | $30 | $300 |
| FLUX.2 [klein] 9B | $4 | $40 | $400 |
| Seedream 5 Lite | $8 | $80 | $800 |
| Nano Banana 2 Lite | $10 | $100 | $1,000 |
| FLUX.2 [pro] | $30 | $300 | $3,000 |
| GPT Image 2 (standard) | $32 | $320 | $3,200 |
| Nano Banana 2 | $35 | $350 | $3,500 |
| Seedream 5 Pro | $35 | $350 | $3,500 |
| Wan 2.7 Image Pro | $35 | $350 | $3,500 |
| FLUX.2 [max] | $70 | $700 | $7,000 |
| Nano Banana Pro | $80 | $800 | $8,000 |
| GPT Image 2 (high quality) | $95 | $950 | $9,500 |
At 100K images/month, the spread between FLUX.2 Klein 4B and GPT Image 2 at high quality is $9,200.
"I was generating maybe 500 images/day for product mockups and the bill went from what I expected to be ~$15 to over $45 because I didn't realize the reference image I was sending counted as input tokens too." — r/AI_Agents thread on cheap image APIs
Budget Models Under $0.02/Image
Three models sit below the $0.02 line at 1024x1024:
FLUX.2 Klein 4B and 9B ($0.003-$0.004/image) are Black Forest Labs' smallest checkpoints. The 4B produces usable images for thumbnails, placeholders, and bulk background generation. It struggles with fine text and photorealistic faces. The 9B is marginally better on composition for a fraction of a cent more. Both require a BFL API key with no free tier.
Nano Banana 2 Lite (~$0.010/image) runs on Google's Gemini 3.1 Flash Lite backbone. It's the fastest Nano Banana model, optimized for speed over detail. Google's docs call it "not optimized for multiple reference inputs or multi-turn sequential editing." For single-prompt generation where speed matters more than precision, it's the cheapest option from a major provider that also has a free tier.
Seedream 5 Lite (~$0.008/image) from ByteDance sits between Klein and Nano Banana 2 Lite on both price and quality. Strong on lighting and stylized content, weaker on text rendering. Available through Seedream V5 Lite on AIReiter.
Where budget models work: thumbnails, social media fill images, prototyping, batch placeholder generation. Where they break: complex embedded text, photorealistic human portraits at print resolution, prompts requiring precise spatial composition.
The $0.02-$0.05 Production Sweet Spot
This tier is where most production workloads should land. The quality jump from budget to mid-tier is large; the jump from mid-tier to premium is marginal.
I ran the same prompt ("professional product photograph of a matte black coffee mug on a marble countertop, soft morning light") through four models at 1024x1024, default settings, single generation each:
FLUX.2 Pro ($0.030/image) from Black Forest Labs delivers strong creative and artistic output at the lowest price in this tier. Prompt adherence and compositional control are its strengths. Available through FLUX.2 Pro on AIReiter.
GPT Image 2 (~$0.032/image at standard quality) from OpenAI leads this tier on photorealism and text rendering accuracy. Its per-token billing means costs scale with output complexity: a simple icon generates fewer output tokens (lower cost) than a detailed scene with embedded text (higher cost). OpenAI's image generation guide includes a cost calculator for precise estimates. Available through GPT Image 2 on AIReiter.
Nano Banana 2 (~$0.035/image) from Google is the most versatile model in this tier. Native 4K support, strong text rendering, up to 10 reference images per call, and multi-turn editing make it the practical default when you need a single model for product shots, infographics, and iterative edits. Available through Nano Banana 2 on AIReiter.
Seedream 5 Pro (~$0.035/image) from ByteDance excels at lighting, skin tones, and realistic environments, making it a strong pick for portrait-style commercial photography. Available through Seedream V5 Pro on AIReiter.
For e-commerce and marketing, any model in this tier produces output that rarely needs re-touching. The differences come down to style preference.
Premium Models Over $0.05/Image
Nano Banana Pro (~$0.080/image) is Google's top-tier image model, built on the Gemini 3 Pro backbone. It offers the highest level of world knowledge, brand consistency, and precision creative control in the Nano Banana family. The 2.3x premium over Nano Banana 2 pays for itself when accuracy on the first attempt saves re-generation cycles. Available through Nano Banana Pro on AIReiter.
GPT Image 2 at high quality (~$0.095/image) generates more output tokens for finer detail. At standard web resolution, the quality difference from standard-quality GPT Image 2 is hard to see. The improvement is most visible at print resolution and for ad creatives where pixel-level detail matters.
FLUX.2 Max ($0.070/image at 1024x1024) is BFL's highest-quality checkpoint. The quality gap over FLUX.2 Pro shows up most clearly on complex multi-subject compositions.
The case for premium: if you're generating 50 hero images per month and each one replaces a $200 stock photo shoot, paying $0.08 instead of $0.03 is irrelevant. Premium models earn their price when first-pass quality eliminates rework.
Costs That Don't Show Up on Pricing Pages
The per-image price is the floor, not the ceiling. Three items silently inflate the actual bill:
Resolution multipliers. All models charge more for larger images, but the scaling differs. BFL's megapixel pricing is linear: a 2048x2048 image costs ~2.6x a 1024x1024. OpenAI's token-based pricing can scale faster because more detailed images generate disproportionately more tokens. Google's image output tokens also increase with resolution, though the exact ratio depends on model and content. If you're generating at 2K or 4K, recalculate with the actual resolution.
Failed generations still cost money. When a prompt triggers a safety filter, OpenAI returns an error but the input tokens are already billed. Google's Nano Banana models similarly charge for input tokens on rejected prompts. If even a small percentage of prompts are rejected (product imagery with human models is particularly prone), a high-volume pipeline bleeds input-token costs on generations that produce nothing.
Rate limit retries. Hitting 429 errors and retrying adds latency. If your retry loop re-sends the full prompt (including reference images), you pay duplicate input token charges on token-based APIs. Implementing exponential backoff and caching reference image tokens where possible reduces this cost.
FAQ
What is the cheapest AI image generation API right now?
FLUX.2 Klein 4B at roughly $0.003 per 1024x1024 image from Black Forest Labs. For a free option, Google's Nano Banana 2 Lite has a limited free tier through the Gemini API.
Is Google's free Nano Banana tier enough for production?
For low-volume use under ~1,500 images/day, yes. The free tier caps at ~15 requests per minute and Google's terms state that free-tier usage data may be used to improve their products. The paid tier ($0.30/M input, $2.50/M output tokens for Nano Banana 2 Lite) removes both constraints.
Does cheaper always mean worse quality?
Not in the $0.02-$0.05 range. FLUX.2 Pro at $0.030 and GPT Image 2 at $0.032 produce output quality comparable to models at 2-3x their price for standard web use. The quality gap is real below $0.01/image, but the mid-tier is competitive enough that style preference matters more than raw price.
How do I estimate my monthly image generation cost?
Multiply your expected image count by the per-image price at your target resolution. Add a buffer for failed generations and retries. For token-based APIs (OpenAI, Google), factor in input token costs if you send reference images: a single 1024x1024 reference adds roughly 1,000-2,000 input tokens per call.