OpenAI GPT-5 Nano: 400K context, 83.7 AA Math, text/image/file input, $0.05/M input tokens via OrcaRouter.
OpenAI GPT-5 Nano (2025-08-07 release) is a smaller, cost-optimized member of the GPT-5 family. It offers a context window of 400,000 tokens—enough to process entire long documents or book-length…
GPT-5 Nano accepts text, image, and file inputs, allowing it to reason over a mix of formats. Its 400,000-token context can hold hundreds of pages of text along with embedded images or document attachments. The model can generate up to 128,000 tokens in a single response, suitable for long analytical outputs, code generations, or multi-step mathematical proofs. Its AA Math score of 83.7 demonstrates strong arithmetic and logical reasoning. Common use cases include long-document summarization, image-to-text annotation, file-based data extraction, and educational problem solving where both understanding of charts and textual context is required.
Best use cases exploit the model’s large context and multi-modal input without demanding maximum benchmark performance. Example: processing a 300-page legal contract plus attached exhibits (images of signatures, tables) to extract obligations. Another: analyzing a long research paper with figures, then writing a 10,000-word critique. In education, GPT-5 Nano can work through a complex math problem step-by-step, using images of handwritten equations. For data pipelines, it can ingest PDFs and images, outputting structured data. These tasks benefit from the low input cost ($0.05/M tokens) and the ability to handle files directly.
If your application never requires more than, say, 8,000 tokens of context and does not need image or file inputs, a smaller and cheaper model (e.g., GPT-4 Mini at lower token cost) would be more economical. Similarly, if your outputs are always very short (e.g., single‑word classifications), paying $0.40 per 1M output tokens may be wasteful—consider a model optimized for classification at lower output cost. GPT-5 Nano is most cost‑effective when you genuinely need its 400K context window or multi‑modal capabilities; otherwise, simpler models will save money.
The AA Math benchmark evaluates mathematical reasoning—solving arithmetic, algebra, and word problems. A score of 83.7 indicates that GPT-5 Nano correctly solved 83.7% of the tasks in this benchmark. This is a strong performance for a “nano” model, implying it can reliably handle grade‑school through early high‑school level math, including multi‑step problems. Compare this with larger models that may score above 90 but come at a higher per‑token cost. The score confirms that for math reasoning, GPT-5 Nano offers a good cost‑accuracy trade‑off for many applications.
Latency figures for GPT-5 Nano are not publicly disclosed by OpenAI as of the 2025-08-07 release. In practice, speed depends on factors such as total token count, request load, and OrcaRouter’s infrastructure. Because Nano is a smaller model relative to large variants, it likely has lower per‑token latency, but exact numbers are unavailable. OrcaRouter handles requests asynchronously with standard timeout configurations. For latency‑sensitive real‑time applications, we recommend benchmarking with your typical payload (including images/files) via the OrcaRouter API to assess suitability.
Strengths: Long context (400K tokens), multi‑modal input (text/image/file), large output capacity (128K tokens), solid math reasoning (83.7 AA Math), and low per‑token cost. Limitations: It is not the top‑performing model on other benchmarks (scores not provided for coding, reasoning, or knowledge tasks). Its smaller parameter count likely means it struggles with highly nuanced or creative tasks. Also, latency not guaranteed; no support for audio or video input. Output quality may degrade on very long generations near the 128K limit. For tasks needing state‑of‑the‑art scores, consider larger GPT‑5 models.
Pricing is based on token usage, charged at the OpenAI provider rate with zero markup. Input tokens: $0.05 per 1 million tokens. Output tokens: $0.40 per 1 million tokens. OrcaRouter passes through these exact rates. For a typical conversation using 100,000 input tokens (including images tokenized as part of the input) and 10,000 output tokens, the cost would be ($0.05 × 0.1) + ($0.40 × 0.01) = $0.005 + $0.004 = $0.009 (less than one cent). Billing is metered at the token level; you can set spending limits via the OrcaRouter dashboard.
GPT-5 Nano’s main advantage is low input cost relative to its context size. For example, processing a 400K‑token document costs only $0.02 for input (400K / 1M × $0.05). Output tokens are more expensive per token, so if your application generates very long responses, the output cost can dominate. For instance, a 100K‑token output costs $0.04 (100K / 1M × $0.40). Evaluate your average input‑to‑output ratio. If outputs are short but inputs are huge, Nano is extremely cheap. If outputs approach 128K, consider whether a cheaper output‑rate model exists for your specific task.
OrcaRouter does not disclose specific caching mechanisms for individual models. Standard API best practices apply: reuse responses at the application level when appropriate, and minimize redundant token consumption. Note that because GPT-5 Nano supports file and image inputs (which are tokenized), each unique file or image counts as new input tokens. Caching tokenized content is not supported at the API level. To optimize costs, you can cache the text portions of your prompts client‑side and avoid resending identical long contexts if the model’s answer is deterministic and you control temperature=0.
Use the OpenAI‑compatible API endpoint: base URL https://api.orcarouter.ai/v1, model ID "openai/gpt-5-nano-2025-08-07". Example with curl:\n\ncurl https://api.orcarouter.ai/v1/chat/completions \n -H "Authorization: Bearer YOUR_ORCAROUTER_API_KEY" \n -H "Content-Type: application/json" \n -d '{\n "model": "openai/gpt-5-nano-2025-08-07",\n "messages": [{"role": "user", "content": [{"type": "text", "text": "Solve this math problem."},{"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}]}],\n "max_tokens": 512\n }'\n\nAll standard parameters (temperature, top_p, stop, frequency_penalty, etc.) are supported. File inputs can be base64‑encoded or URL‑based.
GPT-5 Nano supports the standard chat completions parameters: model (required, use the exact ID), messages (array of message objects), max_tokens (up to 128000), temperature (0–2, default 1), top_p (0–1, default 1), n (number of completions, default 1), stop (string or array), frequency_penalty, presence_penalty, user (unique identifier for tracking), and logit_bias. For image and file inputs, use content objects with type "image_url" (for images) or "file" (for file attachments, if supported—check OrcaRouter docs). Parameters like tools, tool_choice, and response_format are available when the model supports structured output.
Migration is straightforward because OrcaRouter implements the exact same OpenAI‑compatible schema. Change just two things: 1) Set the base URL to https://api.orcarouter.ai/v1; 2) Replace your OpenAI API key with an OrcaRouter API key (obtain from the OrcaRouter dashboard). Keep all other request bodies unchanged, including model IDs formatted as "openai/gpt-5-nano-2025-08-07". OrcaRouter handles routing and billing. No code changes beyond the endpoint and key are needed. Test with a single request to confirm connectivity and token usage accounting.
For file inputs, include a content object with type "file" and supply the file data as base64 encoding or a public URL. OrcaRouter accepts the same schema as OpenAI’s API. Example message content: [{"type": "text", "text": "Summarize this PDF"}, {"type": "file", "file": {"url": "..."}}]. The tokenized cost of files depends on their size and complexity (images are counted as input tokens proportional to resolution). Ensure your total context (text+image+file tokens) stays under 400,000. For very large files, consider pre‑splitting or using a different strategy.
GPT-5 Nano offers a larger context window (400K vs. GPT‑4 Mini’s typical 128K) and multi‑modal input (text/image/file vs. text‑only in many Mini variants). Its cost is lower: $0.05/$0.40 per M tokens vs. GPT‑4 Mini rates that are often higher for output. However, GPT‑4 Mini may provide faster inference (though latency figures are not published for either). The AA Math score of GPT‑5 Nano (83.7) is competitive with or exceeds GPT‑4 Mini’s math performance. For long‑context, multi‑modal tasks, Nano is the clear choice; for short generic text, Mini may still be cost‑effective.
GPT-5 Pro is OpenAI’s large flagship model with higher benchmark scores across the board but also higher token pricing (exact rates not provided). Pro likely has a smaller context window (rumored 128K) but better reasoning, coding, and creativity. GPT-5 Nano trades some accuracy and capabilities for a much lower price and longer context. If your priority is maximum quality on difficult tasks, choose Pro. If you need to process huge amounts of data economically and can accept moderate accuracy, Nano is superior. Both are accessible via OrcaRouter with the same API format.
OrcaRouter provides access to many models. Alternatives include larger OpenAI models (GPT‑5 Pro) for higher accuracy, smaller models (GPT‑4 Mini) for simple text, or third‑party models like Anthropic’s Claude or Meta’s Llama. Each has different context windows, pricing, and modality support. For example, Claude 3 Haiku may offer faster speed but no image input. You can compare costs per token on the OrcaRouter pricing page. GPT-5 Nano stands out specifically for its combination of 400K context, multi‑modal input, and low input cost—making it unique among lightweight models.
GPT-5 Nano, like other OpenAI models accessed via API, does not train on your data by default (OpenAI’s API data usage policy applies). OrcaRouter acts as a proxy and does not store your prompts or responses beyond what is necessary for billing and request logging (subject to their privacy policy). Both providers commit to not using API data for model improvement unless you opt in. For sensitive data, consider using a local or dedicated model. GPT‑5 Nano’s data handling is identical to that of other OpenAI API models—no additional data retention by OrcaRouter.
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-nano-2025-08-07",
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.
GET /api/public/models/openai/gpt-5-nano-2025-08-07Open @misc{orcarouter_gpt_5_nano_2025_08_07,
title = {openai/gpt-5-nano-2025-08-07 API},
author = {openai},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/openai/gpt-5-nano-2025-08-07}
}openai. (n.d.). openai/gpt-5-nano-2025-08-07 API. OrcaRouter. https://www.orcarouter.ai/models/openai/gpt-5-nano-2025-08-07