GPT-5-Nano is the smallest and fastest variant in the GPT-5 system, optimized for developer tools, rapid interactions, and ultra-low latency environments. While limited in reasoning depth compared to its larger...
GPT-5 Nano is a small-scale model in OpenAI’s GPT-5 family, optimized for low-cost inference while retaining a large context window of 400,000 tokens and a maximum output of 128,000 tokens. It…
GPT-5 Nano accepts three input modalities: text, image, and file. Text inputs are straightforward. Image inputs allow the model to process visual information (e.g., diagrams, screenshots) and answer questions about them. File inputs let you attach PDFs, Word documents, or other file types for document-level analysis. All modalities can be combined in a single request. The model processes these inputs within its 400,000-token context window. Note that image tokens consume from the context budget; a high-resolution image may use several thousand tokens. This multimodal support makes GPT-5 Nano suitable for tasks like chart reading, form extraction, and mixed-media analysis.
The model supports a context window of 400,000 tokens (including both input and output tokens) and a maximum output of 128,000 tokens. This allows processing of very long documents – for example, a book-length text or a multi-page report – in a single request. The generous output limit means the model can produce lengthy responses, such as full summaries or extended analysis. However, large outputs also incur higher output token costs at $0.40 per 1M tokens. Developers should consider setting max_tokens parameters appropriately to avoid unintended cost escalation.
Given its strong math benchmark (AA Math 83.7), the model excels at arithmetic word problems, math tutoring, and quantitative reasoning. Its multimodal capabilities make it useful for interpreting scanned math worksheets, diagrams, or charts. The low pricing supports high-volume applications like automated customer support, content categorization, and real-time data extraction from files. For simple text generation (e.g., short email drafts, bullet-point summaries), GPT-5 Nano provides a cost-effective alternative to larger models. It is less suitable for creative storytelling, code generation, or tasks requiring deep factual recall.
If your task is extremely simple (e.g., single-word classification, yes/no questions) and does not require the large context or multimodal support, even smaller or cheaper models like OpenAI’s GPT-3.5 Turbo might suffice. GPT-5 Nano’s price is already low, but for tasks that involve only short inputs and output (e.g., a few tokens each), a model with even lower per-token pricing could reduce cost further. Also, if you do not need the 400k context, a model with smaller context but lower fixed overhead may be more economical. Always benchmark on your data to find the best cost-performance trade-off.
GPT-5 Nano achieves a score of 83.7 on AA Math, which is a benchmark measuring arithmetic and math word problem solving at a grade-school level. This score indicates strong performance for such tasks relative to its model size. AA Math includes addition, subtraction, multiplication, division, and multi-step word problems. The 83.7 result suggests the model can handle many common math queries accurately, though it may still err on more complex or multi-step problems. No other benchmark scores are provided for this model, so comparisons on coding, general knowledge, or reasoning are not available.
No specific latency figures were provided for GPT-5 Nano. However, as a small model, it is generally expected to be faster per token than larger models like GPT-4o. OrcaRouter serves the model via its OpenAI-compatible API, and network latency depends on user location and provider infrastructure. For real-time applications, testing latency with representative inputs is recommended. The model’s small parameter count typically allows for higher throughput on the same hardware, which can reduce wait times in production settings, especially under high concurrency.
Based on the provided AA Math score of 83.7, GPT-5 Nano is strong at mathematical reasoning and arithmetic. This makes it suitable for educational tools, data analysis, and any task that involves structured numerical processing. Its ability to handle images and files further supports document-centric math problems. Weaknesses include the absence of benchmarks in other domains such as coding (HumanEval), general knowledge (MMLU), or conversational fluency. Users should not assume equal performance in non-math tasks. The model may also be less capable of understanding subtle context or generating long-form creative content.
Without benchmarks for reasoning, coding, or common sense, GPT-5 Nano’s general intelligence cannot be quantified. Its 83.7 AA Math score, while respectable, does not guarantee proficiency in other areas. The model is small, so it may produce more factual errors or less coherent outputs on ambiguous topics compared to larger models. Its 400k context window is large, but effectively using that context may require careful prompt engineering. The lack of a provided speed rating means real-world latency should be verified. Users should perform their own evaluations on task-specific metrics before deployment.
GPT-5 Nano is priced at $0.05 per 1 million input tokens and $0.40 per 1 million output tokens. These rates are set by OpenAI and passed through by OrcaRouter with zero markup. Input tokens include the prompt and any image or file tokens. Output tokens are the generated response. Both directions are billed based on token count. For a typical 1,000-token prompt and 500-token response, the cost would be approximately $0.00005 (input) + $0.0002 (output) = $0.00025 per request. This is competitive for a model with 400k context window and 128k output.
While GPT-5 Nano is inexpensive, output tokens cost eight times more than input tokens ($0.40 vs $0.05 per 1M). For applications that generate long responses (e.g., 10k+ output tokens), output costs can dominate. Developers should cap max_tokens to the minimum needed. Input tokens from images and files are billed at the same input rate, but high-resolution images consume many tokens (e.g., a 1-megapixel image may use ~2,000 tokens). Using lower resolution or reducing image count can lower costs. The large context window encourages long prompts, but every extra token adds cost. Balance context size with token budget.
OrcaRouter passes through OpenAI’s pricing without markup, but caching policies are determined by OpenAI. The provider may offer caching for repeated identical input prefixes, which would reduce input token charges. However, no specific details about caching for GPT-5 Nano were provided. Developers should check OpenAI’s documentation for their caching policies. OrcaRouter does not add its own caching layer; it acts as a transparent gateway. If caching is available, it can significantly lower costs for applications with repetitive prompts, such as automated customer support or template-based generation.
To use GPT-5 Nano, set the base URL to https://api.orcarouter.ai/v1 and specify the model ID as "openai/gpt-5-nano" in your API request. The endpoint is OpenAI-compatible, so you can use any OpenAI SDK or HTTP client. A typical request includes parameters like messages, max_tokens, temperature, and stop sequences. OrcaRouter forwards the request to OpenAI and returns the response with no additional processing. Authentication is done via an API key provided by OrcaRouter. This makes migration simple for users already using OpenAI’s API: just change the base URL, model ID, and API key.
All standard OpenAI chat completions parameters are supported through OrcaRouter’s proxy – for example, messages (with roles: system, user, assistant), max_tokens, temperature, top_p, frequency_penalty, presence_penalty, stop, and stream. For multimodal inputs, you can include image_url or file_type fields in the content array. The model also supports function calling and tools, though these are not detailed in the provided facts. Parameters like n (number of completions) and logprobs may also be available. Refer to OpenAI’s API documentation for the full list. OrcaRouter does not modify or restrict parameters.
Migrating to GPT-5 Nano is straightforward. If you currently use OpenAI’s API, change the base URL to https://api.orcarouter.ai/v1, replace your API key with an OrcaRouter key, and set the model to "openai/gpt-5-nano". The request format remains identical. You may need to adjust temperature and max_tokens to suit the smaller model. Test with a subset of your prompts to evaluate output quality. Since GPT-5 Nano has a smaller parameter count, it may respond differently to instructions; prompt tuning may be needed. OrcaRouter provides no markup, so cost comparisons are direct.
GPT-4o is a larger, more capable model with higher benchmark scores across most domains (e.g., MMLU, HumanEval) but also higher pricing. GPT-5 Nano is optimized for cost and speed. GPT-4o’s context window is currently smaller (128k tokens) than GPT-5 Nano’s 400k tokens, though GPT-4o offers stronger reasoning and creativity. For tasks that require the large context or focus on math problems, GPT-5 Nano may be more appropriate. For complex coding, nuanced conversation, or tasks demanding high accuracy, GPT-4o is likely superior. The choice depends on your budget and performance requirements.
GPT-3.5 Turbo is an older small model with comparable pricing but a much smaller context window (16k tokens) and no multimodal support. GPT-5 Nano offers a 400k context window, 128k output, and image/file inputs, making it far more capable for long-document and multimodal tasks. However, GPT-3.5 Turbo may be sufficient for short, text-only interactions and may have lower latency due to its smaller context handling. Benchmark comparisons are not available, but GPT-5 Nano’s AA Math score of 83.7 suggests better math reasoning. For pure text-only short tasks, GPT-3.5 Turbo remains a cost-effective option.
GPT-4o Mini is a smaller variant of GPT-4o with similar multimodal support and a context window of 128k tokens. GPT-5 Nano offers triple the context (400k tokens) and a larger output limit (128k vs 16k for GPT-4o Mini). Pricing of GPT-4o Mini (typically $0.15/M input, $0.60/M output) is higher than GPT-5 Nano’s $0.05/$0.40. However, GPT-4o Mini likely excels in general reasoning and instruction following due to being a distilled version of GPT-4o. GPT-5 Nano’s single strong benchmark (AA Math) suggests it is specialized for math. Choose GPT-5 Nano for math-heavy tasks with large context; choose GPT-4o Mini for broader capabilities.
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="openai/gpt-5-nano",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoningmax_completion_tokensmax_tokensreasoningresponse_formatseedstreamstructured_outputstool_choicetools| Input / 1M tokens | $0.050 |
|---|---|
| Output / 1M tokens | $0.400 |
| Cache read / 1M | $0.0050 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
Compare monthly costs across models in the LLM cost calculator
What developers are saying this week
GET /api/public/models/openai/gpt-5-nanoOpen @misc{orcarouter_gpt_5_nano,
title = {GPT-5 Nano API},
author = {OpenAI},
year = {2025},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/openai/gpt-5-nano}
}OpenAI. (2025). GPT-5 Nano API. OrcaRouter. https://www.orcarouter.ai/models/openai/gpt-5-nano