Gemini 3.1 Flash Lite Preview is Google's high-efficiency model optimized for high-volume use cases. It outperforms Gemini 2.5 Flash Lite on overall quality and approaches Gemini 2.5 Flash performance across...
Google Gemini 3.1 Flash Lite Preview is a preview release of a lightweight variant from the Gemini 3.1 series. It is designed to deliver strong reasoning and multimodal understanding at a fraction of…
Google Gemini 3.1 Flash Lite Preview excels at tasks that require processing large volumes of textual or multimodal data in a single context. Use cases include long-document question answering, where the entire text can be fed as context; video summarization and analysis, where multiple frames or clips are combined; and audio transcription with contextual reasoning. The high context window makes it effective for tasks like contract review, legal research, and academic paper analysis. Its 82.2 GPQA Diamond score suggests strong performance on graduate-level reasoning questions, so it is also useful for complex problem-solving in science, math, and engineering. Additionally, its multimodal support enables tasks such as image captioning combined with text instructions, or file-based data extraction from PDFs and spreadsheets.
The model's primary strengths are its very large 1M token context window, multimodal input capabilities, and competitive reasoning performance at a low price. The $0.25/$1.50 per million token pricing is among the most affordable for a model with this context size and benchmark score. The GPQA Diamond result of 82.2 indicates that the model can handle complex, multi-step reasoning tasks that often require deep understanding. The ability to accept text, image, video, file, and audio in the same request means that applications can correlate information across modalities without external data fragmentation. For developers using OrcaRouter, the zero-markup billing ensures that costs remain predictable and aligned with provider rates. The OpenAI-compatible API further reduces integration friction.
Despite its low cost, this model may be overkill for very simple tasks like short-form text classification, small-scale summarization, or single-turn translations. For such use cases, even cheaper embeddings or dedicated classifiers could be more cost-effective. Additionally, if your application requires extremely low latency (sub-100ms), a purpose-built flash model or a smaller variant may be preferable. The preview nature of this model also means that it is not yet fully optimized for production reliability; for mission-critical workloads, a stable release or alternative may be more appropriate. Finally, if your context lengths are consistently short (e.g., <10K tokens), a smaller, cheaper model with similar capabilities could yield lower per-request costs.
GPQA Diamond is a benchmark consisting of multiple-choice questions at the level of graduate-level scientific reasoning. A score of 82.2 means that the model answered 82.2% of these challenging questions correctly. This places it well above random chance and indicates strong reasoning ability, particularly in domains like physics, chemistry, and biology. It suggests that the model can handle nuanced, multi-step inference that requires domain knowledge and logical deduction. While GPQA Diamond is a good indicator of reasoning depth, it does not measure other aspects like creativity, instruction following, or safety. For comparison, many models achieve scores in the 60–80% range, with the best models occasionally exceeding 90%. Thus, 82.2 is a competitive result for a lightweight preview model.
Exact latency figures for Google Gemini 3.1 Flash Lite Preview have not been publicly disclosed by Google. In general, "Flash Lite" models in the Gemini family are designed to prioritize throughput and cost efficiency over raw speed. They typically have higher per-request latency compared to dedicated "Flash" models when context is long, due to the large context window size. However, for short prompts, latency may be comparable to other lightweight models. Because the model runs on Google's infrastructure through OrcaRouter, network latency and queuing may also affect end-to-end response time. Users should benchmark with their own data and expected context sizes to determine if latency meets their requirements. If ultra-low latency is essential, consider using a smaller model or a faster dedicated endpoint.
As a preview model, Google Gemini 3.1 Flash Lite Preview may have lower reliability and stability compared to production releases. It may exhibit occasional off-target responses or inconsistencies in multimodal integration. The 82.2 GPQA score, while strong, is lower than the best performing full-size models; for extremely complex reasoning chains, a larger model may be necessary. The model's support for video and file inputs is subject to format constraints and may not handle all codecs or file types. Additionally, the 1M context window is a limit; processing near that boundary may lead to increased latency and memory usage. Finally, because it is accessed through OrcaRouter, users are subject to OrcaRouter's API policies and any rate limits they impose. No data is logged by default, but users should verify configuration.
Pricing for Google Gemini 3.1 Flash Lite Preview is based on token usage, with separate rates for input and output tokens. Input tokens are billed at $0.25 per 1 million tokens, and output tokens at $1.50 per 1 million tokens. These are the provider rates from Google; OrcaRouter adds zero markup, so the price you see is the price the provider charges. There are no additional fees for authentication or API access beyond standard usage. Billing is measured in tokens, which correspond roughly to words or image/video/audio chunks as defined by the tokenizer. Because the model supports multimodal inputs, each image, video frame, or audio segment is also tokenized and counted toward the input total. Pricing is transparent and predictable for users who monitor their token counts.
The 1M token context window can significantly increase input token costs if the entire window is used. At $0.25 per million input tokens, filling the full 1M context would cost approximately $0.25 per request plus output charges. For applications that frequently use large contexts, this can still be economical compared to models with higher per-token rates. However, if the input can be truncated or summarized, costs can be reduced. The zero-markup policy from OrcaRouter means that you are not paying extra for using this model through a gateway. For batch processing, the cost per document may be very low because many short documents can be combined into a single request. Conversely, if context windows are always small, a model with a higher per-token rate but shorter context may be more efficient due to lower total token usage.
OrcaRouter's pricing page indicates that standard billing applies to this model; there is no specific mention of caching discounts for Google Gemini 3.1 Flash Lite Preview at this time. Caching is a feature that some providers offer to reduce costs for repeated content, but currently it is not noted for this model. Users should check the latest OrcaRouter documentation or contact support to inquire about any future caching options. In the absence of caching, the cost per request is simply the sum of input and output tokens multiplied by the respective rates. To manage costs, consider using prompt optimization techniques such as reducing unnecessary context, trimming system messages, and batching similar requests together to maximize token efficiency.
To use Google Gemini 3.1 Flash Lite Preview, send requests to OrcaRouter's OpenAI-compatible API endpoint. The base URL is https://api.orcarouter.ai/v1. Set the model parameter to "google/gemini-3.1-flash-lite-preview". Authentication is done via an API key placed in the Authorization header as `Bearer YOUR_API_KEY`. The API supports standard OpenAI chat completion parameters including messages (with roles: system, user, assistant), temperature, top_p, max_tokens, stop, and frequency/presence penalties. For multimodal inputs, use the `content` array format with `type` fields for text, image_url, or other media as supported. The model also accepts file and audio inputs; refer to OrcaRouter's documentation for the exact format for these modalities.
The API accepts most standard OpenAI chat completion parameters. Key parameters include: `messages` (required), `max_tokens` (up to 65,536), `temperature` (0–2, default 1), `top_p` (0–1, default 1), `n` (number of completions, default 1), `stop` (list of strings), `frequency_penalty`, `presence_penalty`, and `stream` (boolean). The model does not support any custom Google-specific parameters beyond those exposed by OrcaRouter's compatibility layer. For multimodal requests, the `content` field in each message accepts an array of objects with `type` (e.g., "text", "image_url", "input_audio") and corresponding data. When using file inputs, the file must be uploaded to a supported URL or base64 encoded inline. OrcaRouter may impose additional restrictions or required fields; consult their API reference for exact details.
If you are already using a Google Gemini model (e.g., gemini-2.0-flash) through OrcaRouter, migrating to this preview model is straightforward. Change the `model` field in your API requests from the old model ID to "google/gemini-3.1-flash-lite-preview". No other changes to the API endpoint, authentication, or message format are required. However, be aware that the new model may have different tokenization, output length limits, and behavior. It is recommended to test with a few sample requests and compare outputs. The input modalities are the same as other Gemini models, so multimodal payloads should work without modification. If you were using any model-specific parameters not in the OpenAI-compatible set, they may need to be removed or adapted. Finally, note that this is a preview model, so it may not be available in all regions or may have limited capacity.
The base URL for all API calls is https://api.orcarouter.ai/v1. The exact model identifier to use in the `model` parameter is "google/gemini-3.1-flash-lite-preview". This identifier is case-sensitive. For example, a complete curl request would look like: curl https://api.orcarouter.ai/v1/chat/completions -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d '{"model":"google/gemini-3.1-flash-lite-preview","messages":[{"role":"user","content":"Hello"}]}'. Make sure to replace YOUR_API_KEY with your actual OrcaRouter API key. The response format follows OpenAI's chat completion structure, including id, object, choices, and usage fields with token counts.
Compared to Gemini 2.0 Flash, the 3.1 Flash Lite Preview offers a much larger context window (1M vs 128K tokens) and a higher maximum output (65K vs 8K tokens). Its GPQA Diamond score of 82.2 is significantly higher than the 2.0 Flash's typical mid-60s range, indicating stronger reasoning. Pricing for 3.1 Flash Lite Preview is $0.25/$1.50 per million tokens, while Gemini 2.0 Flash is $0.10/$0.40 per million tokens — so the new model is more expensive per token but offers much greater context and reasoning capability. For tasks that require the larger context and higher reasoning, the price premium may be justified. For short-context, simple tasks, Gemini 2.0 Flash remains more cost-effective. Both support multimodal inputs, but 3.1 adds file and audio modalities.
GPT-4o mini has a context window of 128K tokens and output of 16K tokens, with prices at $0.15/$0.60 per million tokens. Google Gemini 3.1 Flash Lite Preview has a 1M context window, 65K output, and pricing of $0.25/$1.50. The Gemini model offers 8x the context and 4x the output, but at roughly 67% higher input cost and 150% higher output cost. On GPQA Diamond, GPT-4o mini scores around 82 as well, making them comparable in reasoning. The choice depends on context needs: if you require >128K context, the Gemini model is the only option. If context is small, GPT-4o mini is cheaper. Additionally, the Gemini model supports file and audio inputs, which GPT-4o mini does not through the standard API.
Claude 3 Haiku by Anthropic offers a 200K context window and output of 8K tokens, with pricing $0.25/$1.25 per million tokens — very similar input cost but slightly lower output cost than the Gemini model. Gemini 3.1 Flash Lite Preview has 5x the context and 8x the output. GPQA Diamond scores for Claude 3 Haiku are not publicly available from Anthropic, but Haiku is optimized for speed and short-form tasks, not deep reasoning. The Gemini model's 82.2 GPQA suggests stronger reasoning, while Haiku likely has lower latency. For cost-sensitive, high-volume tasks with moderate context, Haiku may be better. For tasks needing very long context or multimodal reasoning (video, audio, files), the Gemini preview offers distinct advantages. Both are accessible via OrcaRouter with OpenAI-compatible APIs.
The full Gemini 3.1 Flash model typically has a context window of 256K tokens and output of 8K tokens, with pricing around $0.10/$0.40 per million tokens. The Lite Preview version has a much larger 1M context and 65K output, but is more expensive ($0.25/$1.50). The Lite variant is designed for cost efficiency at scale, whereas the full Flash model is optimized for speed and short prompts. On benchmarks, the full Flash may achieve slightly higher scores on some metrics, but the Lite Preview's GPQA score of 82.2 is competitive. The Lite version also supports more input modalities (file, audio). The "Preview" label indicates it is an early release; the full Flash is production-ready. If you need the largest possible context and don't mind the higher per-token cost, the Lite Preview is the better choice. For fast, short interactions, the full Flash remains preferable.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1https://api.orcarouter.aifrom openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key="$ORCAROUTER_API_KEY",
)
response = client.chat.completions.create(
model="google/gemini-3.1-flash-lite-preview",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoningmax_tokensreasoningresponse_formatseedstopstructured_outputstemperaturetool_choicetoolstop_p| Input / 1M tokens | $0.250 |
| Output / 1M tokens | $1.50 |
| Cache read / 1M | $0.025 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
GET /api/public/models/google/gemini-3.1-flash-lite-previewOpen @misc{orcarouter_gemini_3_1_flash_lite_preview,
title = {Gemini 3.1 Flash Lite Preview API},
author = {Google},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/google/gemini-3.1-flash-lite-preview}
}Google. (2026). Gemini 3.1 Flash Lite Preview API. OrcaRouter. https://www.orcarouter.ai/models/google/gemini-3.1-flash-lite-preview