Gemini 2.5 Flash Image, a.k.a. "Nano Banana," is now generally available. It is a state of the art image generation model with contextual understanding. It is capable of image generation,...
Google: Nano Banana (Gemini 2.5 Flash Image) is a multimodal language model developed by Google, part of the Gemini 2.5 Flash series. It accepts both image and text as input and generates text…
The core capabilities center on understanding and reasoning about visual content presented as images. Given an image and a text prompt, the model can describe the scene, identify objects, answer questions about the content, extract text (OCR), and perform basic visual reasoning (e.g., spatial relationships, colors, actions). It can also process text that accompanies the image, such as instructions or context. Because it uses a flash-tier architecture, it is optimized for low latency and high throughput, making it suitable for real-time or high-volume applications. However, it may not match the depth of reasoning or accuracy of more expensive, larger models like Gemini 2.5 Pro on complex visual tasks requiring fine-grained analysis or lengthy reasoning chains. The model is not designed for tasks like image generation, video analysis, or multi-turn conversations that require long context beyond 32K tokens.
If your application does not require image input at all, using a text-only model (e.g., a smaller Gemini variant or an open-source model) would be more cost-effective. Similarly, if your task involves only text-based reasoning with no visual component, the image processing overhead is unnecessary. For scenarios where output length is long—such as generating detailed reports or stories from an image—the $30 per million output tokens can become expensive. In such cases, consider models with lower output pricing, or use this model to generate a brief summary and then expand it with a cheaper text-only model. Additionally, if you need to process multiple images per request or handle very large images, models with larger context windows or specific image resolution support may be more appropriate.
High-volume deployments benefit from this model's low input cost ($0.30 per million tokens) and fast inference. Ideal use cases include automatic image tagging for large photo libraries, generating alt-text for thousands of product images, performing OCR on batches of scanned documents, and real-time content moderation of user-uploaded images. Because the output cost is high, the response should be kept short—often a single word, label, or sentence. For example, classifying an image into predefined categories, extracting a few key fields from a form, or answering a yes/no question about an image. Batch processing can be done via OrcaRouter's API with concurrent requests. The model's latency is generally low, but actual throughput depends on image size and complexity. There is no separate rate limit in OrcaRouter other than the overall API usage.
The primary limitation is the high output token cost relative to input cost, making long text generation expensive. The context window of 32,768 tokens limits how much text and how large an image (in token terms) can be processed in a single request. The model is not designed for tasks requiring deep multimodal reasoning, intricate visual details, or handling multiple images at once (each additional image consumes context). Furthermore, as a flash-tier model, it may exhibit lower accuracy on specialized visual tasks such as medical image analysis, fine-grained object detection, or rare object recognition compared to more capable but slower or costlier models. The model's training data and specific performance on benchmarks are not disclosed in the provided facts; users should evaluate on their own datasets. Finally, it only supports image and text input, not video or audio.
The provided facts do not include any specific benchmark scores for Google: Nano Banana (Gemini 2.5 Flash Image). It is part of Google's Gemini 2.5 Flash series, which generally targets efficiency rather than top-tier accuracy. In the absence of numbers, users should expect performance comparable to other flash-tier multimodal models on standard vision-language tasks such as VQAv2, COCO Captions, and OCR. However, exact scores are not given. We recommend evaluating the model on your own representative dataset to determine if its capabilities meet your requirements. OrcaRouter does not provide internal benchmarks beyond what is publicly available from Google. If you require precise accuracy metrics, consult Google's official documentation for the Gemini 2.5 Flash series, but note that this specific model identifier may have its own fine-tuning.
The provided facts do not include latency measurements for this model. As part of the Gemini 2.5 Flash family, it is designed for low latency and high throughput. Typically, flash-tier models from Google trade some reasoning quality for speed, making them suitable for near-real-time applications. The actual latency depends on factors such as the size and resolution of the input image, the length of the text prompt, the number of output tokens requested, and the current load on the API. In general, simple image captioning tasks may complete in a few hundred milliseconds to a couple of seconds, while more complex prompts requiring longer output will take longer. For best results, keep the image resolution reasonable and limit the output length. OrcaRouter's API has no added overhead beyond the provider's response time.
Strengths: The model excels at tasks where a fast, cost-effective answer is needed from a single image. It can quickly identify common objects, read text from images, and answer direct questions about visual content. The low input cost makes it feasible for processing large volumes of images. Limitations: It may struggle with tasks requiring high precision, such as counting small objects, distinguishing very similar textures, or understanding complex diagrams. The model's understanding is limited to what can be inferred from the pixel data and the text prompt; it does not have access to external knowledge beyond its training data (cutoff unknown). Additionally, because the output cost is high, generating verbose answers for each image can quickly become expensive. For tasks that require long, detailed analysis, a more capable (and typically more expensive) model would be more appropriate. Performance on edge cases like dark blurry images or unusual angles may be lower.
Pricing is straightforward: $0.30 per 1 million input tokens and $30.00 per 1 million output tokens. Input tokens include the tokens from both the text prompt and the image (the image is tokenized by the model). Output tokens are the tokens generated as the response. There is no setup fee, no monthly minimum, and OrcaRouter adds zero markup—you pay exactly the provider rate. Tokens are counted by OrcaRouter's system. Billing is typically usage-based, with charges incurred as you send requests. You can monitor usage through the OrcaRouter dashboard. Because input tokens are much cheaper than output tokens, the total cost for a typical request (short output) is dominated by the input side, especially if you include a large image. For example, a 1024x1024 image may consume several thousand input tokens.
Compared to text-only models (e.g., Gemini 1.5 Flash text-only at $0.075/M input, $0.30/M output), this model's input cost is 4x higher and output cost 100x higher, reflecting the added complexity of vision. For tasks that require no image analysis, those text-only models are far cheaper. Compared to larger multimodal models like Gemini 2.5 Pro (which has higher per-token costs but better reasoning), this model is cheaper on input but similar or higher on output depending on the specific Pro tier. The flash-tier trade-off is lower accuracy for lower input cost. If your application needs high accuracy and can tolerate higher input cost, a Pro model may be better. If output length is large, this model's output cost becomes prohibitive, so consider models with lower output pricing, such as Gemini 1.5 Flash (text+vision) which may have different rates.
The provided facts do not mention any caching mechanisms or volume discounts for this model on OrcaRouter. OrcaRouter passes through the provider's pricing without markup, so any discounts would have to come from Google's direct billing arrangements. As of now, there is no automatic caching of image embeddings or prompts in OrcaRouter's published information. Users should assume that each request is billed based on the input and output tokens used. For high-volume users, it may be worth contacting OrcaRouter to inquire about potential enterprise agreements, but standard pay-as-you-go pricing is $0.30/M input and $30.00/M output. To minimize costs, reuse previously generated outputs where possible, and limit the number of tokens in each request (e.g., by resizing images or using brief prompts).
To use Google: Nano Banana (Gemini 2.5 Flash Image) via OrcaRouter, send a POST request to https://api.orcarouter.ai/v1/chat/completions with the model parameter set to "google/gemini-2.5-flash-image". The API follows the OpenAI chat completions format. Include your OrcaRouter API key in the Authorization header as "Bearer YOUR_API_KEY". In the request body, provide a messages array with a user message that contains both image and text. For images, include a content part of type "image_url" with the URL or base64 data. Example: {"model":"google/gemini-2.5-flash-image","messages":[{"role":"user","content":[{"type":"text","text":"What is in this image?"},{"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}]}],"max_tokens":50}. The response will be a standard chat completion with the model's answer.
The OrcaRouter API supports many of the same parameters as the OpenAI API. Essential parameters: model (required, set to "google/gemini-2.5-flash-image"), messages (required, array of message objects), max_tokens (integer, maximum tokens to generate), temperature (float, defaults to 1.0, controls randomness), top_p (float, defaults to 1.0), presence_penalty and frequency_penalty (floats), stop (string or array of strings, up to 4 sequences), and stream (boolean, for streaming responses). For image input, the messages must include at least one user message with content that is an array of parts, each part with a type field ("text" or "image_url"). The image_url part must have an "image_url" object with a "url" string (either a publicly accessible URL or a data URL with base64). There is no fine-tuning or additional model-specific parameters exposed. The context window is 32,768 tokens, so ensure prompt_token_count + image_token_count + max_tokens <= 32768.
Migrating to OrcaRouter requires minimal code changes if you already use an OpenAI-compatible API. Simply change the base URL from your previous endpoint to https://api.orcarouter.ai/v1. Update your API key to your OrcaRouter key. When calling the model, set the model parameter to "google/gemini-2.5-flash-image" (or your desired model). Adjust any existing model IDs accordingly. For image input, ensure your request format matches the OpenAI convention (e.g., using content array with image_url). No other code changes are typically needed. If you were using a different API format (e.g., cloud endpoints), you may need to rewrite the request structure. OrcaRouter provides documentation for common SDKs. Test with a small number of requests to verify token counts and pricing. Note that OrcaRouter bills provider rates without markup, so pricing may differ from your previous provider.
Compared to the text-only Gemini 2.5 Flash (if available on OrcaRouter), this model adds image input capabilities but at a higher input cost. The text-only version typically costs less per input token and has significantly lower output cost, making it preferable for purely text tasks. Compared to Gemini 2.5 Pro models, this flash-tier model is cheaper on input but may have lower accuracy and reasoning depth. Pro models have a larger context window (often 1 million tokens) and better performance on complex multi-step tasks. Output cost for Pro models may be similar or higher. For tasks that require understanding of images alongside text, this model offers a cost-effective entry point. However, if you need to process video, audio, or multiple images simultaneously, you should consider a model that supports those modalities (e.g., Gemini 2.5 Pro which supports video and audio in some configurations).
This model is one of many multimodal options available through OrcaRouter. GPT-4o (OpenAI) typically has a larger context window (128k) and may offer better overall image understanding and reasoning, but at higher input and output costs. Claude's vision models (e.g., Claude 3.5 Sonnet) are also competitive but differ in pricing and context length. The Gemini 2.5 Flash Image's main advantage is its low input cost, making it attractive for high-volume, short-output tasks. However, for complex visual reasoning, healthcare imaging, or detailed document analysis, more advanced models may produce better results. The choice depends on the specific trade-off between cost, accuracy, and latency. OrcaRouter allows you to easily switch between models by changing the model ID, so it's feasible to test this model alongside alternatives to determine the best fit.
A more expensive model—such as Gemini 2.5 Pro, GPT-4o, or Claude 3.5 Sonnet—becomes justified when the task demands higher accuracy, longer context, or reasoning that requires more steps. If your application produces incorrect or incomplete results with this model, the cost savings are wasted if you need post-processing or human correction. For tasks like analyzing medical images, interpreting legal documents, or handling sensitive compliance content, the reliability of a premium model may warrant the higher cost. Also, if you need to generate long outputs (e.g., full page descriptions) or process very large images, models with larger context windows and lower output token costs could be more cost-effective overall. The flash-tier nature of this model means it is designed for speed and throughput, not for depth. Use it where approximate understanding is sufficient; upgrade when precision matters.
Data privacy and handling depend on Google's policies for Gemini models. As with any cloud API, input data (images and text) is sent to Google's servers for processing. Google may use the data for model improvement unless you opt out or use enterprise-grade accounts that prohibit such use. The provided facts do not specify data handling details for this particular model. When using OrcaRouter as a gateway, the data passes through OrcaRouter's infrastructure but is ultimately processed by Google. OrcaRouter does not store your data or use it for training. Users should review Google's data processing terms for Gemini APIs and consider end-to-end encryption if needed. For sensitive data, some organizations prefer models hosted on their own infrastructure (e.g., via Vertex AI with data residency) rather than a third-party gateway. However, OrcaRouter provides a unified API key and billing, which may simplify access if data handling concerns are acceptable.
https://api.orcarouter.aimax_tokensresponse_formatseedstopstructured_outputstemperaturetop_p| Input / 1M tokens | $0.300 |
| Output / 1M tokens | $30.00 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
GET /api/public/models/google/gemini-2.5-flash-imageOpen @misc{orcarouter_gemini_2_5_flash_image,
title = {Nano Banana (Gemini 2.5 Flash Image) API},
author = {Google},
year = {2025},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/google/gemini-2.5-flash-image}
}Google. (2025). Nano Banana (Gemini 2.5 Flash Image) API. OrcaRouter. https://www.orcarouter.ai/models/google/gemini-2.5-flash-image