OpenAI GPT-5.4-2026-03-05: 1.05M context, 128K output, 92.0 GPQA Diamond. Text, image, file input.
This is a large language model from OpenAI with a context window of 1,050,000 tokens and a maximum output of 128,000 tokens. It accepts text, image, and file inputs, allowing users to combine visual…
Given its 1.05M context and multi-modal support, it excels at tasks like analyzing long financial reports with embedded charts, summarizing entire legal discovery documents, examining large codebases for bugs or patterns, and conducting academic research over lengthy papers. It can combine several images (e.g., slides from a presentation) with textual context and produce a unified summary. The 128K max output also makes it suitable for generating comprehensive reports, complete software projects, or extended narrative content that would be truncated by models with smaller output limits. Use cases that require high reasoning capability, such as multi-step math or logic problems, also benefit from the benchmark scores.
If your task involves short inputs and outputs (e.g., chatbot conversations under 4K tokens, simple classification, or brief translations), a smaller model like OpenAI's GPT-4o mini or GPT-4o may be more cost-effective and faster. Also, if the task does not require the reasoning depth measured by GPQA Diamond, a cheaper model can achieve acceptable results at lower cost. Because pricing for this model on OrcaRouter is not publicly available, it is likely that the per-token cost is higher than for smaller models. Evaluate whether the extended context and output size are necessary; if not, a lighter model will reduce both monetary cost and latency.
The model natively handles text, image, and file inputs within the same context window. This means you can send a request that includes a text prompt, a few images (e.g., photographs, diagrams), and attached files (e.g., PDFs, spreadsheets) as part of the message array. The model will reason across all modalities. For example, you could ask it to compare a diagram in an image with data in a CSV file and produce a textual analysis. Note that image and file processing consume tokens from the context window; a large image may use thousands of tokens, so plan your requests accordingly to stay within 1,050,000 tokens.
The file input modality covers common document formats such as PDF, Word, Excel, PowerPoint, text files, and possibly image formats beyond typical web images. While the exact file MIME types are not specified in the provided facts, OrcaRouter likely supports the same range as OpenAI's file endpoints. For best results, use text-based files (PDF, TXT, code) because images are handled separately through the image modality. The model can extract text from files and incorporate it into its reasoning. If you need to analyze an image that is embedded in a file (e.g., a PDF with pictures), it is better to extract the image separately and send it via the image input.
GPQA Diamond is a benchmark consisting of graduate-level multiple-choice questions in biology, physics, and chemistry. A score of 92.0 indicates that the model answered 92% of these questions correctly. This is a strong result, suggesting the model possesses deep reasoning and domain-specific knowledge. However, benchmark scores do not guarantee perfect performance in every real-world scenario. The model may still produce errors on nuanced tasks or topics outside its training distribution. This score is a comparative metric: it shows that this model outperforms many earlier models on this specific test, but for domain-specific high-stakes applications, always validate outputs.
Strengths include the ability to process very long contexts, handle multiple modalities, and produce lengthy outputs. The high GPQA Diamond score indicates strong reasoning. Limitations: as with all LLMs, it can generate plausible-sounding but incorrect information (hallucination). The large context window means that if a user provides conflicting or irrelevant information within the context, the model may struggle to focus on important parts. Also, because the model is large, inference latency may be higher than smaller models. The model's maximum output of 128,000 tokens is generous but still finite; extremely long generations may still be truncated if the output exceeds that limit. No latency or speed figures are publicly provided.
The only specific benchmark provided is GPQA Diamond at 92.0. For comparison, earlier OpenAI models like GPT-4 (August 2023) scored around 38.0 on GPQA (the higher bar of Diamond). GPT-4o (May 2024) scored approximately 75-80 on GPQA Diamond (publicly known). Therefore, this model shows improvement. For other benchmarks like MMLU, HumanEval, etc., no data is provided; users should assume typical strong performance expected from a flagship OpenAI model. The key differentiator is the context and output size: GPT-4o has a 128K context and 16K output, whereas this model has 1.05M context and 128K output. So for very long documents, this model is the better choice.
No multimodal benchmarks (e.g., on image captioning or visual question answering) are included in the provided facts. However, given that the model supports image and file inputs, it is reasonable to assume it performs well on standard vision-language tasks, likely comparable to or better than GPT-4o's vision capabilities. Users interested in specific multimodal accuracy should test the model on their own datasets. The GPQA Diamond score (text-only) gives a baseline for reasoning, but does not cover visual reasoning. For tasks that require reading text from images, the model uses optical character recognition internally, but no separate OCR accuracy figures are provided.
Pricing for openai/gpt-5.4-2026-03-05 on OrcaRouter is not publicly disclosed in the available facts. Typically, models with very large context windows and high output limits command a higher per-token price due to the computational resources required. For current pricing, you should refer to the OrcaRouter dashboard or contact their support. When budgeting, consider that the high max output (128K tokens) can lead to larger bills per request. Some platforms offer caching discounts for repeated prompts; check OrcaRouter's documentation for details. For cost-sensitive workloads, evaluate whether smaller models can achieve acceptable results for part of the pipeline.
OrcaRouter may offer caching mechanisms where prompts that are repeated across requests are stored temporarily to reduce cost. This is common across many API providers. For a model with a 1.05M context, caching can be especially beneficial if you often use the same system prompt or a large static document. However, the specific caching policies for this model are not detailed in the provided facts. You can likely enable caching by setting appropriate headers or using OrcaRouter's built-in features. Without caching, each request processes the full context, so costs scale linearly with input length. To optimize, pre-process inputs to remove irrelevant content before sending them.
No pricing numbers are provided for any model in the facts. As a general note, models with larger context windows and newer release dates tend to be priced higher than earlier models. GPT-4o, which has a 128K context and 16K output, would likely be cheaper than this model. For frequent short requests, the lower cost of GPT-4o may be more economical. For long-document tasks, the context window of GPT-4o may be insufficient, forcing chunking and multiple calls; in that case, the higher per-token cost of this model may actually be lower overall because it avoids extra processing. Users should run their own cost estimates based on actual usage patterns.
Set the base URL to https://api.orcarouter.ai/v1 and use the model ID "openai/gpt-5.4-2026-03-05" in the request body. The API is fully compatible with the OpenAI Python client, curl, or any HTTP client that supports the chat completions endpoint. Example with openai library in Python: ```python import openai client = openai.OpenAI(base_url="https://api.orcarouter.ai/v1", api_key="YOUR_KEY") response = client.chat.completions.create( model="openai/gpt-5.4-2026-03-05", messages=[{"role":"user","content":"Explain quantum computing"}], max_tokens=2048 ) ``` All standard parameters are supported. Remember to replace YOUR_KEY with an OrcaRouter API key.
The minimum required parameters are "model" (string, must be "openai/gpt-5.4-2026-03-05") and "messages" (array of message objects). Each message object requires a "role" (system, user, or assistant) and "content". For multi-modal input, the content can be an array of content parts (text, image_url, or file). The model also supports a "max_tokens" parameter (integer up to 128,000). If omitted, the model may generate until the stop condition. Other optional parameters include temperature, top_p, frequency_penalty, presence_penalty, stop, and stream. All follow the OpenAI Chat Completions specification.
Migration involves changing the base URL and possibly updating the API key. If your code currently uses the OpenAI Python client with default base URL (api.openai.com), you only need to instantiate the client with base_url="https://api.orcarouter.ai/v1" and your OrcaRouter API key. The model ID changes from the OpenAI model name (e.g., "gpt-5.4-2026-03-05") to "openai/gpt-5.4-2026-03-05" (note the provider prefix). All other parameters remain the same. Test with a simple request first. This model may have slightly different behavior than the same model when accessed directly through OpenAI, but it should be functionally identical for most use cases.
GPT-4o (specifically the gpt-4o-2024-08-06 version) has a context window of 128,000 tokens and a max output of 16,384 tokens. In contrast, openai/gpt-5.4-2026-03-05 offers a context window of 1,050,000 tokens (about 8.2 times larger) and a max output of 128,000 tokens (about 7.8 times larger). This makes the newer model far better suited for tasks involving entire books, massive codebases, or long conversation histories, and for generating extended outputs like full reports. However, GPT-4o may have faster inference and lower cost. Benchmark-wise, GPT-4o's GPQA Diamond score is lower (approx. 80) compared to 92.0, indicating better reasoning on graduate-level questions. For tasks that fit within GPT-4o's context, it remains a strong alternative.
GPT-4 Turbo (gpt-4-turbo-2024-04-09) has a context window of 128,000 tokens and max output of 4,096 tokens. Its GPQA Diamond score is significantly lower (around 38). Therefore, the 5.4 model outperforms it on both context, output, and reasoning. Since GPT-4 Turbo is older, it may still be used for lower-cost short tasks, but for any long-context or high-reasoning workload, this model is superior. The newer model also supports image and file inputs natively, while GPT-4 Turbo's vision capabilities were introduced later and are not as integrated.
OrcaRouter likely offers other OpenAI models (e.g., openai/gpt-4o, openai/gpt-4-turbo) as well as models from other providers. If you need a context window larger than 128K tokens but smaller than 1.05M, you might consider models like Anthropic's Claude 3.5 Sonnet (200K context) or Google's Gemini 1.5 Pro (1M context). The choice depends on your specific requirements for reasoning, multimodal support, and output length. This model stands out for its combination of a very large context and high reasoning score. For best results, test your specific use case with a sample request through OrcaRouter's API to compare output quality across models.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key="$ORCAROUTER_API_KEY",
)
response = client.chat.completions.create(
model="openai/gpt-5.4-2026-03-05",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoningmax_completion_tokensmax_tokensreasoningresponse_formatseedstreamstructured_outputstool_choicetools| Tier | Input / 1M tokens | Output / 1M tokens | Cache read / 1M |
|---|---|---|---|
| ≤ 272K | $2.50 | $15.00 | $0.250 |
| ≤ ∞ | $5.00 | $22.50 | $0.500 |
| Tier selected by input token count of each request | |||
Estimate based on list price
Tiered pricing — this estimate uses base-tier rates.
Estimate only — actual token counts depend on the provider's tokenizer.
GET /api/public/models/openai/gpt-5.4-2026-03-05Open @misc{orcarouter_gpt_5_4_2026_03_05,
title = {openai/gpt-5.4-2026-03-05 API},
author = {openai},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/openai/gpt-5.4-2026-03-05}
}openai. (n.d.). openai/gpt-5.4-2026-03-05 API. OrcaRouter. https://www.orcarouter.ai/models/openai/gpt-5.4-2026-03-05