Gemini 3.5 Flash-Lite is Google's most cost-efficient Gemini model, purpose-built for very high-volume, latency-sensitive workloads where cost per call dominates. Despite its price point it is natively multimodal — accepting text, images, video, audio, and files with text output — and carries the same 1M-token context window and up to 64K output tokens as the larger Flash tier, so long documents and mixed-media inputs remain in reach. At roughly a fifth of the price of 3.6 Flash, it is the right tool for classification, extraction, routing, summarization, lightweight agents, synthetic-data generation, and any pipeline run millions of times. It still supports configurable reasoning effort, native tool calling, and structured outputs, and punches above its weight on agentic and long-context benchmarks for a lite model — for example 74.0% on OSWorld-Verified and 72.2% on 128k multi-needle retrieval, comfortably ahead of the prior 3.1 Flash-Lite. It speaks both the OpenAI chat-completions format and Gemini's native generateContent API, so you can mix it with heavier models behind a single integration — routing easy, high-volume traffic to Flash-Lite and escalating hard tasks to 3.6 Flash or a Pro model.
Google Gemini 3.5 Flash-Lite is a multimodal language model developed by Google, offered through OrcaRouter's OpenAI-compatible API. It accepts text, image, video, file, and audio inputs, making it…
Gemini 3.5 Flash-Lite is capable of a wide range of tasks thanks to its multimodal input and tool‑use support. It handles text‑only tasks like summarization, question answering, and code generation. With images, it can describe scenes, extract text from documents, or interpret diagrams. Video inputs enable activity recognition, captioning, and temporal reasoning. Audio inputs facilitate transcription, language identification, and speech‑based analysis. The model also supports tool calling, as evidenced by its CharXiv Reasoning score of 76.5 (with tools). This means it can be integrated into agentic workflows where it calls external APIs or databases. However, it is not designed for creative writing, highly abstract reasoning, or tasks requiring deep domain expertise. Its strength lies in speed, cost, and breadth of modality support rather than raw performance.
You should choose Gemini 3.5 Flash-Lite when cost and throughput are primary concerns and the task fits within its capability envelope. It excels at high‑volume pipelines such as indexing thousands of documents, transcribing hours of audio, or running real‑time classification on image streams. Its large context window (1M tokens) makes it ideal for tasks that require a global understanding of long inputs, like judicial case analysis or codebase refactoring. Larger models (e.g., Gemini 3.5 Pro) may achieve higher accuracy on complex benchmarks but come with significantly higher per‑token costs and lower throughput. If your application can tolerate minor quality trade‑offs for a 10‑100x cost reduction, this model is a strong fit. Conversely, for tasks requiring factual precision, creative generation, or state‑of‑the‑art reasoning, a larger model is recommended.
Yes, the model natively accepts video and audio inputs alongside text, images, and files. Video input can be provided as a sequence of frames or a video file; the model processes visual frames and any associated audio track. Audio input works with common formats like WAV, MP3, or FLAC. The large context window allows long recordings to be processed in a single request – for example, a one‑hour audio transcript at high detail might consume around 10,000 tokens. This is useful for meeting summarization, podcast analysis, or voice‑based customer support. Note that the model does not generate audio or video output; responses are always text. The quality of multimodal understanding matches the model's flash‑lite tier: adequate for extraction and classification, but may miss subtle details compared to larger multimodal models.
Gemini 3.5 Flash-Lite supports tool calling, as indicated by its benchmark performance on CharXiv Reasoning with tools (score 76.5). This means you can define functions or APIs that the model can invoke during response generation. Typical use cases include database lookups, web searches, or arithmetic operations. The model chooses when to call a tool based on the user's instruction and the context. Tool use can improve factual accuracy and enable complex multi‑step reasoning. However, because the model is a flash‑lite variant, its tool‑calling reliability may be lower than that of a larger specialized model. If your application depends heavily on flawless tool orchestration, you may need to add validation layers or fallback logic. OrcaRouter passes tool definitions in the same format as OpenAI’s API, making integration straightforward.
The model achieved a score of 76.5 on the CharXiv Reasoning benchmark when evaluated with tools. CharXiv tests the ability to perform reasoning over chart‑based visual data, requiring the model to interpret a chart image and answer questions about it. The “with tools” condition means the model could call external functions (e.g., a calculator) to assist. This score indicates moderate performance – it is capable of chart‑related reasoning but not at the level of specialist models. No other benchmark scores have been provided for this model. For comparison, larger models such as Gemini 3.5 Pro would likely score higher on this task. The value is useful as a reference point: you can expect reasonable chart interpretation, but should test thoroughly if your application demands high accuracy on visual reasoning tasks.
Only the CharXiv Reasoning (with tools) score has been provided: 76.5. No additional benchmark data – such as MMLU, HumanEval, or long‑context retrieval scores – is available for Gemini 3.5 Flash‑Lite in the provided information. This means that generalizing its performance to other tasks requires empirical testing on your own data. Given the model’s flash‑lite nature, it is expected to underperform full‑sized models on most standardized benchmarks. However, its efficiency and low cost often outweigh these deficits in production settings. If you need verified performance on a specific benchmark (e.g., code generation or multilingual understanding), you should run your own evaluation. OrcaRouter does not host separate benchmark results; the numbers quoted here come directly from the provider.
Latency details are not specified in the provided data. As a rule of thumb, flash‑lite models are designed for low latency relative to their larger siblings, but actual response time depends on many factors: input length, output length, concurrent request load, and the underlying hardware. With a 1M context window, processing very long prompts can increase latency substantially due to the quadratic scaling of attention. For short inputs (e.g., a few hundred tokens), you can expect sub‑second responses. For inputs near the 1M token limit, latency could reach tens of seconds. OrcaRouter does not guarantee specific latency SLAs for this model. If low latency is critical, consider using a smaller context (e.g., via truncation) or a dedicated endpoint. You can monitor response times through the OrcaRouter dashboard.
Gemini 3.5 Flash-Lite is not designed for state‑of‑the‑art accuracy. Its strengths are speed, cost, and large context. Limitations include lower performance on complex reasoning benchmarks, reduced factual recall compared to larger models, and a tendency to “hallucinate” on ambiguous inputs. The model may struggle with tasks requiring deep domain expertise (e.g., legal reasoning, medical diagnosis) or nuanced creative work. Its tool‑use capability, while functional, may not be as reliable as that of a dedicated agentic model. Additionally, because only one benchmark score is provided (CharXiv Reasoning 76.5 with tools), you cannot assume good performance on other domains without testing. For critical applications, always benchmark on your own data and consider using a fallback to a more capable model when confidence is low.
Pricing is $0.30 per 1 million input tokens and $2.50 per 1 million output tokens. These rates are the provider rates billed without any markup by OrcaRouter. Input tokens include all tokens in the prompt (text, image tokens, video frames, audio samples, file contents) regardless of modality. Output tokens are the generated text tokens. For a typical long‑context query consuming 100,000 input tokens and 1,000 output tokens, the cost would be approximately ($0.30 * 0.1) + ($2.50 * 0.001) = $0.030 + $0.0025 = $0.0325 per request. At scale, this model can process millions of queries for a few hundred dollars. Compare this to larger models that often cost 10‑50x more per token. The low output pricing is particularly beneficial for applications that generate lengthy responses (e.g., full‑document summaries).
The provided information does not specify any caching mechanism or discounted pricing for cached tokens. Therefore, you should assume that every token sent to the model is billed at the standard input rate of $0.30 per million tokens, regardless of repetition. Some providers offer automatic prompt caching where repeated prefixes are billed at a lower rate (e.g., 50% off). For this model, no such caching discount has been announced. If you frequently resend the same context (e.g., a large system prompt), you may want to investigate whether OrcaRouter or Google implements transparent caching. In the absence of explicit information, it is safest to budget full per‑token costs for all inputs. Optimizing by trimming reused content can reduce your effective bill.
Zero markup means that OrcaRouter charges exactly the provider rate without adding any extra margin. For Gemini 3.5 Flash-Lite, the input price is $0.30/1M tokens and the output price is $2.50/1M tokens – that is what Google charges, and OrcaRouter passes it through without increase. You are not paying any additional platform fee per token. This is unusual among API gateways, which typically add 10‑20% or more. The absence of markup makes this model even more cost‑effective when accessed via OrcaRouter. You still pay for the bandwidth and API infrastructure, but those costs are included in the provider rate; OrcaRouter does not itemize them separately. This pricing model is transparent: the cost shown in your usage dashboard is the final cost.
You call it using OrcaRouter's OpenAI‑compatible API at the base URL https://api.orcarouter.ai/v1. Set the model parameter to "google/gemini-3.5-flash-lite". Both chat completions (POST /v1/chat/completions) and embeddings (if supported) work. For multimodal inputs, you structure messages with a roles array and content objects that may include text, image_url, or file_url fields. Example cURL request: curl -X POST https://api.orcarouter.ai/v1/chat/completions \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"model":"google/gemini-3.5-flash-lite","messages":[{"role":"user","content":[{"type":"text","text":"Describe this image"},{"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}]}]}' You must use an OrcaRouter API key, not a Google API key.
The model supports standard OpenAI‑compatible parameters: model, messages, max_tokens (up to the model's 65,536 limit), temperature, top_p, stop, frequency_penalty, presence_penalty, and tools (for function calling). Additional Google‑specific parameters (like safety_settings) may not be exposed directly; if you need them, check OrcaRouter documentation for equivalents. The model will respect the max_tokens limit. For multimodal input, the type field in content supports: text, image_url, video_url (if OrcaRouter exposes it), audio_url, and file_url. The file type can accept PDFs, CSVs, etc. Note that large media files may need to be pre‑encoded as data URIs or hosted publicly. OrcaRouter may also require the file to be under a certain size. Always consult the latest API docs for exact parameter support.
To migrate from another API provider (e.g., Google AI Studio, Vertex AI, or other gateways) to OrcaRouter, replace the base URL with https://api.orcarouter.ai/v1 and set the model ID to "google/gemini-3.5-flash-lite". If your existing code uses the OpenAI Python client, pass base_url and api_key. Example: from openai import OpenAI client = OpenAI(base_url="https://api.orcarouter.ai/v1", api_key="YOUR_ORCAROUTER_API_KEY") response = client.chat.completions.create(model="google/gemini-3.5-flash-lite", messages=[...]) You may need to adjust multimodal message formatting if your previous provider used a different schema (e.g., Anthropic). OrcaRouter expects the OpenAI format. User content arrays can include multiple parts. Tool definitions are also OpenAI‑style. There is no additional migration fee; you only pay per token as described.
No direct comparison data is provided, but we can reason qualitatively. Gemini 2.0 Flash (if it exists) would likely be an earlier generation flash model. Gemini 3.5 Flash‑Lite is a newer, lite variant with a larger context window (1M vs. likely 128K) and lower pricing. The cost per token for Gemini 3.5 Flash‑Lite is $0.30/$2.50 per million tokens, which is very low. Older flash models may have higher per‑token costs and shorter context windows. However, Gemini 2.0 Flash might have better raw accuracy if it is a full flash model rather than a lite variant. If your task requires the highest quality and you can afford higher cost, the older full flash model could be better. If you need a large context and low cost, the 3.5 Flash‑Lite is the logical choice.
GPT-4o mini from OpenAI is a similar low‑cost, multimodal model. It has a context window of 128K tokens (significantly smaller than 1M) and is priced at $0.15 per million input tokens and $0.60 per million output tokens (as of early 2025; prices may have changed). Gemini 3.5 Flash‑Lite offers a 8x larger context window at 2x the input price and 4x the output price. So Gemini is more expensive per token but provides much larger context capacity. For tasks where the full 1M context is needed (e.g., processing entire books), Gemini Flash‑Lite is more cost‑effective than trying to chunk the input across multiple GPT‑4o mini calls. If context is short, GPT‑4o mini is cheaper and may have better benchmark performance. Neither benchmark scores are directly comparable without data.
No benchmark comparisons are provided. Llama 3.2 90B (assuming this model exists) is a large open‑weights model with a smaller context window (typically 128K tokens) and higher per‑token cost when run via an API. Gemini 3.5 Flash‑Lite is a proprietary model with a far larger context window and very low pricing – one of the cheapest per‑token multimodal models available. Llama 3.2 90B might achieve higher accuracy on many NLP benchmarks due to its size, but it is not multimodal and has a stricter context limit. If your task is text‑only and you need the highest accuracy, Llama 90B (if accessible through OrcaRouter) could be better. For multimodal, long‑context, or high‑throughput scenarios, Gemini Flash‑Lite has clear advantages. The choice depends on the specific requirements of your application.
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.5-flash-lite",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoningmax_tokensreasoningreasoning_effortresponse_formatseedstopstructured_outputstemperaturetool_choicetoolstop_p| Input / 1M tokens | $0.300 |
| Output / 1M tokens | $2.50 |
| Cache read / 1M | $0.030 |
| 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.5-flash-liteOpen @misc{orcarouter_gemini_3_5_flash_lite,
title = {Gemini 3.5 Flash-Lite API},
author = {Google},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/google/gemini-3.5-flash-lite}
}Google. (2026). Gemini 3.5 Flash-Lite API. OrcaRouter. https://www.orcarouter.ai/models/google/gemini-3.5-flash-lite