Qwen3.5 Flash snapshot 2026-02-23 — frozen version of qwen3.5-flash, same capabilities.
qwen/qwen3.5-flash-2026-02-23 is a specific version of the Qwen3.5 Flash model from the Qwen family by Alibaba. It is a multimodal model supporting text, image, and video inputs. Its context window…
This model can perform a wide range of text-based tasks typical of large language models: summarization, translation, question answering, creative writing, code generation, and more. Its large context window makes it especially suitable for tasks that require understanding long documents or maintaining dialogue over many turns. The model is also capable of few-shot and zero-shot learning, meaning it can follow instructions without extensive fine-tuning. However, no specific accuracy metrics are provided for these tasks. For tasks requiring precise mathematical reasoning or factual recall, you may need to evaluate the model against your own benchmarks.
The model accepts image inputs as part of the prompt. It can describe images, answer questions about visual content, and extract text or objects from images. The image is represented as a sequence of tokens that consume part of the context window. The maximum image size or number of images per request is not specified; in practice, high-resolution images will use more tokens. For best results, provide clear, well-lit images. The model does not support image generation or output. No information is provided about whether it handles multi-image sequences or interleaved text and images beyond the typical multimodal format.
Video input is supported, likely by sampling frames and tokenizing them. The model can analyze short video clips for summarization, action recognition, or question answering. Each frame consumes tokens from the context window, so video length is limited by available context. No specific details about frame sampling rates or maximum video duration are provided. For production use, consider preprocessing videos to extract key frames. The model does not generate video output. If your application requires real-time video processing, test latency carefully as video tokenization can be computationally intensive.
This model costs $0.10 per 1M input tokens and $0.40 per 1M output tokens. If your application can tolerate lower accuracy for simpler tasks, smaller models (e.g., Qwen2.5-0.5B) may be even cheaper. If you need higher quality for complex reasoning or creative writing, consider a larger model such as Qwen3.5-Plus (if available) or GPT-4o, which may have higher per-token costs but offer better benchmark performance. The flash variant is ideal for high-volume applications where speed and cost are priorities. There is no fine-tuning or customization offering documented for this model on this page.
The main strengths of this model are its large context window (1,048,576 tokens), multimodal input support (text, image, video), and low per-token pricing ($0.10/$0.40 per 1M tokens). It is designed for speed and efficiency, making it suitable for real-time applications. The flash designation suggests it has been optimized for lower latency compared to larger counterparts. No benchmark scores are provided on this page, so the exact performance on standard NLP or vision tasks is not known. Based on typical flash models, it likely sacrifices some accuracy for throughput and cost.
Honest limitations include the lack of provided benchmark data; without it, users must validate the model's performance on their own tasks. The model is a flash variant, so it may not match the accuracy of larger or general-purpose models on complex reasoning, math, or factual retrieval. Video support may be limited by context and frame sampling efficiency. Since no specific speed or latency numbers are provided, actual throughput depends on OrcaRouter's infrastructure. The model does not support fine-tuning or custom embedding endpoints via this API. Additionally, the model's knowledge cutoff date is not specified; it may not be updated with the latest events.
Latency is not specified for this model on this page. As a flash variant, it is expected to offer faster inference than larger models, but actual speed depends on factors such as input length, hardware used by OrcaRouter, and concurrent request load. For real-time applications, test with representative payloads. OrcaRouter's API endpoint is hosted on scalable infrastructure, but no guarantees on latency are made. Users should benchmark with their own workloads. The large context window may increase time to first token if the entire context must be processed. Requesting only necessary context can improve response time.
No official benchmark data is provided on this page for qwen/qwen3.5-flash-2026-02-23. To evaluate the model, refer to the Qwen model card on Hugging Face or the Qwen GitHub repository for typical Qwen3.5 Flash performance. Common evaluation dimensions include MMLU, HumanEval, and visual QA benchmarks, but results may vary for this specific snapshot. OrcaRouter does not publish its own benchmarks for this model. Users are encouraged to run their own evaluations to determine suitability for their specific use case, especially for safety, bias, or domain-specific accuracy.
The pricing is $0.10 per 1 million input tokens and $0.40 per 1 million output tokens. These are provider rates with zero markup from OrcaRouter. Input tokens include text, image, and video frames. Output tokens count only generated text. There is no per-request fee, and no special pricing for bulk or reserved capacity is documented. Costs are incurred for the sum of input and output tokens used in each API call. For a typical 1,000-token input and 500-token output, the cost is about $0.0003. Because there is no markup, the cost is exactly what Qwen charges.
OrcaRouter bills this model at the provider rate with zero markup. This means you pay exactly $0.10 per 1M input tokens and $0.40 per 1M output tokens without any additional service fee. There are no hidden charges for API requests, authentication, or data transfer as part of the token pricing. However, standard network costs may apply depending on your infrastructure. No free tier is mentioned. This transparent pricing makes it easy to calculate costs and compare with models from other providers that may add margins. The rate is subject to change by the provider; check the OrcaRouter pricing page for updates.
No caching discounts or volume pricing are documented for this model on this page. Each token is billed individually per API call. There is no mention of prompt caching, discounted batch processing, or committed use discounts. If you anticipate high volume, contact OrcaRouter for potential custom arrangements, but no guarantee is made. The pricing structure is straightforward: input tokens at $0.10/M, output tokens at $0.40/M, no free tier. Unlike some providers offering lower prices for cached prompts, this model currently does not advertise such a feature.
At $0.10/$0.40 per million tokens, this model is competitive with many open-weight flash models. For example, some Llama 3.1 8B variants are priced similarly. Larger models like GPT-4o mini often have higher per-token costs. The key differentiator is the zero markup from OrcaRouter, so you pay the exact provider rate. When comparing, also consider the context window size: this model offers 1,048,576 tokens, which may reduce the need for complex chunking. However, without benchmark data, cost alone is not a sufficient basis for selection; evaluate accuracy and latency for your specific task.
To use this model, send requests to OrcaRouter's OpenAI-compatible API endpoint at https://api.orcarouter.ai/v1. Set the model parameter to exactly "qwen/qwen3.5-flash-2026-02-23". You must include an API key (obtained from OrcaRouter) in the Authorization header. The API supports the standard OpenAI chat completions format. Multimodal inputs (images, videos) can be included in the message content list. For example, use the "chat/completions" endpoint with a messages array. No additional configuration is needed. Refer to OrcaRouter's documentation for authentication and rate limits.
The API supports standard OpenAI-compatible parameters: model (required), messages (required), temperature, top_p, max_tokens, stop, frequency_penalty, presence_penalty, stream, and others. max_tokens can be set up to 65,536. The messages array can include system, user, and assistant roles. Multimodal content is structured as objects with type "text" or "image_url". For video, multiple image_url entries may be used. No custom parameters specific to this model are documented. Parameters like stream allow real-time token output. Always test with your desired parameters, as certain combinations (e.g., high temperature with long contexts) may produce unpredictable results.
Migration is straightforward because OrcaRouter's API is OpenAI-compatible. Replace your base URL from https://api.openai.com/v1 to https://api.orcarouter.ai/v1. Change your model ID from any GPT model to "qwen/qwen3.5-flash-2026-02-23". Obtain an OrcaRouter API key and set it in the Authorization header. If your existing code uses the OpenAI Python library, simply update the base_url and api_key in the OpenAI client. Note that the model supports multimodal input, so if you previously used separate vision endpoints, you can now pass images directly in the chat format. Test thoroughly as outputs will differ.
The base URL for all API calls is https://api.orcarouter.ai/v1. The exact model ID is "qwen/qwen3.5-flash-2026-02-23". This string must be used exactly as provided, including the slash and date suffix. The endpoint for chat completions is POST /v1/chat/completions. For streaming, add the stream parameter. No other endpoints (e.g., embeddings, fine-tuning) are listed for this model. Always verify the latest endpoint documentation on OrcaRouter's site. The model ID may differ from what is used natively by Qwen; always use the OrcaRouter model ID.
Qwen3.5-Plus is likely a larger, more capable variant. While no specific details are provided for either model, flash variants generally trade accuracy for speed and lower cost. The flash model has a lower price ($0.10/$0.40 vs typically higher for Plus). Both likely support the same context window and modalities. Choose flash for high-throughput scenarios where perfect accuracy isn't required; choose Plus for complex tasks. Since no benchmark data is available, test both on your own data if possible. The flash model also contains the date tag 2026-02-23, indicating a specific snapshot.
Llama 3.1 8B is a popular open-weight model with a standard context window of 128K tokens. This Qwen flash model offers a much larger context (1,048,576 tokens) and supports image and video input natively, whereas Llama 3.1 is primarily text. Pricing of Llama on OrcaRouter may be similar or slightly different; check the pricing page. For text-only tasks at similar cost, Llama might be preferred if you have existing infrastructure. For multimodal needs, this Qwen model has an edge. Both are accessed via OrcaRouter's OpenAI-compatible API.
GPT-4o-mini from OpenAI is a smaller, cheaper model with a 128K context window. It supports text and image input but not video. Pricing for GPT-4o-mini on OrcaRouter is not given here, but typically it is around $0.15/$0.60 per 1M tokens. This Qwen model is slightly cheaper on input tokens ($0.10) and on output ($0.40). The Qwen model's major advantage is 1M context and video support. However, GPT-4o-mini may be more thoroughly benchmarked and have wider ecosystem support. Choose based on your need for long context or video, and your trust in model performance.
Other flash models, such as Llama 3.2 Flash or Mistral small, typically have smaller context windows (e.g., 128K) and may not support video. This Qwen flash model's million-token context is a standout feature. Pricing is competitive at $0.10/$0.40. Common limitations across flash models include lower accuracy on complex reasoning and factual tasks. For applications that require maximum quality, a non-flash model from the same family or a larger closed model may be better. No specific comparisons on speed or benchmark scores are provided.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key=os.environ["ORCAROUTER_API_KEY"],
)
response = client.chat.completions.create(
model="qwen/qwen3.5-flash-2026-02-23",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)enable_searchenable_thinkinginclude_reasoninglogprobsmax_tokensnparallel_tool_callspresence_penaltyreasoningrepetition_penaltyresponse_formatseedstopstreamstream_optionstemperaturethinking_budgettool_choicetoolstop_ktop_logprobstop_p| Input / 1M tokens | $0.100 |
|---|---|
| Output / 1M tokens | $0.400 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/qwen/qwen3.5-flash-2026-02-23Open @misc{orcarouter_qwen3_5_flash_2026_02_23,
title = {qwen/qwen3.5-flash-2026-02-23 API},
author = {qwen},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/qwen/qwen3.5-flash-2026-02-23}
}qwen. (n.d.). qwen/qwen3.5-flash-2026-02-23 API. OrcaRouter. https://www.orcarouter.ai/models/qwen/qwen3.5-flash-2026-02-23