Gemini 3.1 Flash Image Preview, a.k.a. "Nano Banana 2," is Google’s latest state of the art image generation and editing model, delivering Pro-level visual quality at Flash speed. It combines...
Google: Nano Banana 2 is a multimodal model that processes both images and text input. It is based on the Gemini 3.1 Flash architecture, which emphasizes fast inference. The model accepts image…
The Gemini 3.1 Flash Image Preview model is capable of a range of multimodal tasks including image captioning, visual question answering, document understanding (e.g., extracting information from invoices or forms), and content moderation that combines image and text analysis. It can also perform reasoning over diagrams and charts, such as interpreting graphs or flowcharts. Since it is a flash model, it is optimized for speed, making it suitable for applications that require quick turnaround. However, it may not match the depth of larger, slower models on complex reasoning tasks. Users should evaluate the model on their specific use cases to confirm its performance.
The context window is 65,536 tokens. This means the model can process up to that many tokens in a single prompt, including both the text and the encoded image data. For text-only prompts, this allows handling of documents around 50,000 words. For multimodal inputs, the image tokens consume part of the window, so the usable text capacity is reduced. The exact token cost per image is not specified, but users should account for images taking a significant number of tokens. This context size enables processing moderately long documents with images, but extremely large documents or many images may exceed the limit. In such cases, chunking or summarization may be needed.
If your task does not require image understanding, a text-only model (e.g., Gemini 1.5 Flash or similar) may be cheaper and faster. Additionally, if your application is extremely latency-sensitive and the image processing overhead is unnecessary, a lightweight text model could be preferable. For tasks involving complex, multi-image reasoning or very high detail, a larger, non-flash vision model may offer better accuracy at the cost of speed. The flash variant is designed to be a middle ground. Users should benchmark their own workloads to determine if the trade-off between speed and quality justifies the cost. OrcaRouter offers a range of models; consulting the catalog can help identify alternatives.
The Gemini 3.1 Flash architecture is optimized for low-latency inference. This makes the model well-suited for real-time applications like live chat assistants, interactive Q&A systems, or automated moderation tools that need to respond within seconds. The speed advantage comes from architectural choices that reduce computational overhead, such as fewer parameters or optimized attention mechanisms. While no specific latency numbers are provided, flash models generally output tokens faster than their standard counterparts. This can reduce the perceived wait time for end users. However, the exact speed depends on factors like input size, image complexity, and server load on OrcaRouter. Developers should test with representative inputs.
No official benchmark scores are publicly provided for this specific model at this time. Because it is a preview version (indicated by "Image Preview" in its name), Google may not have released standardized evaluation results. Users should not assume performance levels from other Gemini Flash models, as the image preview variant may differ in capabilities. To assess the model’s quality, OrcaRouter recommends running custom evaluations on your own dataset. Common metrics for multimodal tasks include accuracy on VQA benchmarks, BLEU for captioning, or F1 for document understanding. Without benchmarks, reliance on empirical testing is necessary.
Since the model is built on Gemini 3.1 Flash, it should demonstrate strong text generation capabilities typical of that architecture, such as coherent language, summarization, and reasoning. However, because it is a multimodal variant, its text-only performance might differ from the dedicated text-only Flash model due to the overhead of image processing branches. No comparative benchmarks are available. For pure text tasks, users may find that a simpler, text-only flash model provides equivalent or better quality with lower cost and latency. If you primarily work with text, consider using the gemini-3.1-flash or similar models on OrcaRouter instead.
As a preview model, it may have restrictions or limitations that are not fully documented. Known potential limitations include: the model may not handle very high-resolution images as well as dedicated vision models; it might be less reliable in handling multiple images in a single prompt due to context sharing; and it may be more sensitive to prompt phrasing than specialized models. Additionally, because it is a flash model, it may trade off some reasoning depth for speed, so complex multi-step visual reasoning tasks could be error-prone. Users should thoroughly test edge cases. OrcaRouter recommends reviewing Google's documentation for Gemini for any safety filters or content policies that may apply.
The Gemini 3.1 Flash Image Preview is designed for low latency, but exact speed metrics are not published. Compared to other flash models on OrcaRouter (e.g., Gemini 1.5 Flash or other flash variants), the addition of image processing may increase per-request latency because images need to be encoded and attended to. However, within the flash class, it should be faster than larger, non-flash models that handle images. For users who need both speed and vision, this model is a reasonable choice. If latency is critical and images are not required, a text-only flash model will be faster. OrcaRouter's API provides response times; customers can monitor their own usage.
Pricing for this model on OrcaRouter is determined by the platform and is subject to change. Typically, OrcaRouter charges per token processed (input + output), with additional surcharges for image tokens. For multimodal models, the cost per request is higher than for text-only models because images consume many tokens. Users should consult OrcaRouter’s official pricing page for the current rates for google/gemini-3.1-flash-image-preview. No specific per-token costs are provided here. It is recommended to estimate costs by testing sample requests and reviewing the token usage reported in the API response headers.
Yes, image inputs significantly increase the token count per request, because each image is tokenized into many tokens (typically hundreds to thousands depending on resolution). This directly raises the cost compared to text-only prompts of similar length. If your application can be served with text-only descriptions of images, a text-only model may be cheaper. Conversely, if image understanding is essential, this model offers a single-model solution rather than combining two separate services. Users should weigh the quality of the model’s image interpretation against the added cost. OrcaRouter may offer usage discounts for high-volume customers; contact them for details.
OrcaRouter may provide features like prompt caching or session reuse to reduce redundant processing of image tokens. However, specific implementation details are not publicly documented for this model. Caching can significantly lower costs in applications where the same image is sent repeatedly (e.g., in a Q&A bot with a fixed document). Users should inquire with OrcaRouter’s support team about caching capabilities. Additionally, OrcaRouter might offer tiered pricing or monthly plans that lower per-token costs for committed usage. It is advisable to review the terms of service or contact sales for precise cost optimization strategies.
To use the model, send HTTP POST requests to OrcaRouter's OpenAI-compatible API endpoint: https://api.orcarouter.ai/v1/chat/completions. Set the model parameter to "google/gemini-3.1-flash-image-preview". Include your API key in the Authorization header (Bearer token). The request body should contain a messages array, where each message can have role (system, user, assistant) and content. For images, include an object with type "image_url" and the image URL or base64 data. Example: "content": [{"type": "text", "text": "Describe this photo"}, {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}]. The API returns a standard chat completion response.
The API supports standard OpenAI chat completion parameters: model, messages, max_tokens, temperature, top_p, stop, stream, etc. For image input, the content array must include objects with type "image_url". The image_url object can have either a public URL or a base64-encoded data URI. OrcaRouter may also support optional parameters like max_image_tokens or detail settings (like OpenAI's low/high), but these are not confirmed. Refer to OrcaRouter's API documentation for any additional parameters specific to multimodal models. The response includes usage information such as prompt_tokens (including image tokens), completion_tokens, and total_tokens, which are helpful for cost monitoring.
Migrating from Google's native Vertex AI or AI Studio API to OrcaRouter requires changing the base URL and model identifier. Replace your Google endpoint with https://api.orcarouter.ai/v1/chat/completions. Change the model name to "google/gemini-3.1-flash-image-preview". Authentication: instead of Google service account credentials, use OrcaRouter API keys. The request format becomes OpenAI-compatible: messages array with roles and content. If you were using Google's multimodal input format, you will need to convert images to the image_url format described above. Most SDKs (e.g., OpenAI Python) work with a simple configuration update. Test with a small payload to verify behavior before production migration.
OrcaRouter uses API key authentication. You must obtain an API key from the OrcaRouter dashboard. Include it in the request header as: Authorization: Bearer YOUR_API_KEY. API keys should be kept secret and not exposed in client-side code. For server-to-server communication, use environment variables. OrcaRouter may offer rate limiting and usage quotas; check your account settings. There is no additional OAuth flow or Google-specific authentication required. The API key is tied to your OrcaRouter account and billing plan. If you exceed rate limits, you may receive HTTP 429 status; implement retry logic accordingly.
The standard Gemini 3.1 Flash is a text-only model (or possibly text with limited vision in newer versions). The Image Preview variant explicitly adds vision capabilities, making it suitable for multimodal tasks. In exchange, the image preview model may have a slightly different internal architecture and potentially higher latency or cost due to image processing. For text-only tasks, the standard Flash will likely be faster and cheaper, and possibly offer identical or better quality. Users should pick the image preview variant only when image input is necessary. OrcaRouter offers both models; compare their model IDs.
On OrcaRouter, other multimodal models include GPT-4V, Claude 3 Vision, and Gemini Pro Vision, as well as open-source variants. The Gemini 3.1 Flash Image Preview is positioned as a fast and lower-cost alternative to larger vision models like GPT-4V. It likely trades off some reasoning depth for speed and price. Compared to dedicated image captioning models, this model offers a more general-purpose multimodal chat experience. For specific tasks like OCR or fine-grained visual recognition, specialized models (e.g., Google's own document AI) may perform better. Users should evaluate based on their use case: this flash model is best for speed-critical applications where moderate vision capability suffices.
OrcaRouter provides a unified OpenAI-compatible API for this Google model, simplifying integration if you already use that interface. You avoid directly managing Google Cloud resources, IAM permissions, or separate SDKs. OrcaRouter may offer additional features like load balancing, caching, fallback models, and consolidated billing. It also aggregates multiple providers, allowing easy model switching without code changes. For this specific model, OrcaRouter handles the backend connectivity to Google's infrastructure, potentially optimizing routing. However, using a third-party gateway introduces a dependency and may add minor latency overhead. Evaluate whether the convenience outweighs direct access.
Choose this model when your application requires understanding of visual content combined with text, such as analyzing photos, diagrams, or scanned documents. If your task involves interpreting images as part of the reasoning process — for instance, in a customer support bot that reads screenshots — this model eliminates the need to use a separate vision API. However, if your images are only decorative or can be described textually, a text-only model will be more economical and faster. Also, if you need extremely high accuracy on specialized visual tasks (like fine-grained object recognition), a dedicated computer vision model would be superior. This model offers a convenient middle ground.
https://api.orcarouter.aiinclude_reasoningmax_tokensreasoningresponse_formatseedstopstructured_outputstemperaturetop_p| Per request | $0.1510 |
| Currency | USD |
| Flat fee per API call (image generation models) | |
GET /api/public/models/google/gemini-3.1-flash-image-previewOpen @misc{orcarouter_gemini_3_1_flash_image_preview,
title = {Nano Banana 2 (Gemini 3.1 Flash Image Preview) API},
author = {Google},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/google/gemini-3.1-flash-image-preview}
}Google. (2026). Nano Banana 2 (Gemini 3.1 Flash Image Preview) API. OrcaRouter. https://www.orcarouter.ai/models/google/gemini-3.1-flash-image-preview