OpenAI's GPT-5.2 with 400K context, 128K output, 99.0 AA Math, priced at $1.75/$14 per 1M tokens via OrcaRouter.
OpenAI's GPT-5.2-2025-12-11 is a large language model from the GPT-5 series, released in December 2025. It is designed to handle extended context lengths and multimodal inputs, including text,…
With a 400,000-token context window, the model can process entire books, lengthy research reports, extensive codebases, or long conversation histories in a single request. This enables tasks such as summarizing a full novel, analyzing a complete legal contract, or maintaining coherent dialogue over hundreds of turns. The 128,000-token maximum output allows the model to generate substantial content, like drafting a long report or producing a large block of code. This extended context capability reduces the need for chunking or external memory, simplifying development workflows for applications that rely on large-scale information processing.
The model accepts three input modalities: file, image, and text. This means you can provide PDFs, spreadsheets, or other file types as input, as well as images such as diagrams, screenshots, or photographs. The model processes these alongside text prompts, enabling tasks like explaining a chart, extracting data from an image, or summarizing a scanned document. While the exact token cost for images and files depends on how the provider encodes them, the pricing model applies to the resulting token usage. Multimodal capability is especially useful for applications that need to integrate visual information with natural language reasoning.
The model excels at tasks that require deep mathematical reasoning, as reflected by its 99.0 AA Math score. It is also well-suited for long-form content generation, multimodal analysis, and complex problem-solving. Best use cases include: academic research where papers contain extensive equations; software engineering where entire libraries must be understood or generated; legal analysis where documents span hundreds of pages; and customer support chatbots that need to recall entire conversation histories. However, for simpler or shorter tasks, a smaller and cheaper model might be more cost-effective. The model's strengths are most apparent when its large context and reasoning capabilities are fully utilized.
If your use case involves short prompts, simple queries, or tasks that do not require deep mathematical reasoning, a cheaper model may be more appropriate. For example, for basic classification, short text generation, or low-latency chat, a model like GPT-4o-mini or a smaller open-source alternative could deliver acceptable results at a fraction of the cost. The high output price of $14.00 per 1M tokens makes the model expensive for applications that generate large amounts of text without need for the extended context or math strength. Evaluate whether your task benefits from the 400K context and 99.0 AA Math performance before committing to this model.
The headline benchmark for this model is 99.0 on the AA Math evaluation. AA Math is a test designed to assess mathematical reasoning abilities at a high level, including algebra, arithmetic, calculus, and logical problem-solving. A score of 99.0 indicates that the model can solve nearly all presented math problems correctly, placing it among the top-performing models on this specific metric. While this benchmark is a strong indicator of mathematical competence, it is not a comprehensive measure of overall intelligence or suitability for all tasks. Users should consider additional evaluation on their specific domain if math performance is critical.
Latency and throughput depend on the size of the input, the requested output length, and current traffic on OrcaRouter's API. Because the model is large and supports up to 128,000 output tokens, very long generations can take significant wall-clock time. For short responses (a few hundred tokens), latency is typically in the range of a few seconds. The service does not publicly disclose per-model token-per-second rates, but users with high-throughput needs may want to test with their own workloads. Streaming responses (using the stream parameter) can reduce perceived latency for interactive applications. The model is accessed via the same OpenAI-compatible endpoint, so latency characteristics are similar to other models served through OrcaRouter.
The model's primary strength is mathematical reasoning, as confirmed by its AA Math score of 99.0. It also demonstrates strong abilities in processing very long contexts (up to 400K tokens) and generating large outputs (up to 128K tokens). Its multimodal input support allows it to reason over images and files, making it versatile for data analysis and document understanding. For tasks that require synthesizing information across long documents or performing complex analytical reasoning, this model is likely to outperform smaller alternatives. Additionally, the zero-markup pricing through OrcaRouter means you pay the provider rate without additional fees.
Despite its strengths, the model has limitations. The high cost per output token ($14.00 per 1M tokens) can quickly add up for applications that generate large volumes of text. Its performance on non-mathematical reasoning tasks may not be proportionally better than cheaper alternatives. The model may also exhibit typical LLM weaknesses such as hallucination, especially with obscure or very recent information. Multimodal input processing may incur higher token usage than expected, depending on how images and files are tokenized. Finally, the context window of 400K tokens is for input total; the model may still struggle with extremely long dependencies within that window, though it performs well overall.
Pricing is based on token usage: $1.75 per 1 million input tokens and $14.00 per 1 million output tokens. These are the provider rates passed through by OrcaRouter with zero markup. Input tokens include text, images, and files as encoded by the provider. Output tokens are generated by the model. Costs are calculated per request, and the total bill is the sum of input and output token costs. For example, a request with 10,000 input tokens and 2,000 output tokens would cost approximately $0.0000175 (input) + $0.000028 (output) = $0.0000455. Users can monitor usage via OrcaRouter's logging and billing dashboard.
The output price ($14.00 per 1M tokens) is eight times the input price ($1.75 per 1M tokens). This is consistent with the provider's pricing structure for large models, reflecting the computational cost of autoregressive generation. Generating tokens sequentially requires significant GPU memory and compute, especially for models with 400K context windows. For applications that require long outputs, the output cost will dominate. Users should design prompts to minimize output length where possible, or consider caching repeated responses. OrcaRouter does not add any markup to these rates, so the pricing you see is the provider's price.
Yes. Because the model's output tokens are expensive, it is worth evaluating whether the task genuinely needs the high mathematical accuracy or the long context. For shorter or simpler outputs, a cheaper model may suffice. Additionally, using multimodal inputs can increase input token costs if images are encoded into many tokens. You can mitigate costs by compressing images or using text-only prompts when possible. OrcaRouter offers caching for repeated prompts (if enabled), which can reduce input token costs for identical or similar requests. However, the model's pricing is pay-as-you-go, with no discounts for bulk usage unless the provider introduces them.
OrcaRouter provides a caching feature that can reduce costs for repeated input tokens. When caching is enabled, identical input prefixes may be stored and reused across requests, so you are not charged for re-processing the same tokens. This is particularly beneficial for applications that frequently send the same system prompts, few-shot examples, or large context chunks. The cache is typically maintained for a limited time (e.g., minutes to hours). Users can configure caching parameters via the API. The exact savings depend on the repeat rate of your inputs. Note that output tokens are never cached, as they are generated per request.
You call the model via OrcaRouter's OpenAI-compatible API at base URL https://api.orcarouter.ai/v1. Use the standard OpenAI chat completions endpoint with the model parameter set to "openai/gpt-5.2-2025-12-11". Your API key (obtained from OrcaRouter) is sent in the Authorization header as Bearer token. Example using Python and the OpenAI library: import openai openai.api_base = "https://api.orcarouter.ai/v1" openai.api_key = "your-key" response = openai.ChatCompletion.create( model="openai/gpt-5.2-2025-12-11", messages=[{"role":"user","content":"Solve 2+2"}] ) The response format matches OpenAI's ChatCompletion structure. Streaming is supported by setting stream=True.
All standard OpenAI Chat Completion parameters are supported, including: model (required), messages (array of message objects), max_tokens (up to 128,000), temperature, top_p, frequency_penalty, presence_penalty, stop, and stream. For multimodal inputs, you can include image or file URLs in the message content using the standard OpenAI content parts structure (e.g., content: [{"type":"image_url","image_url":{"url":"..."}}]). The model also supports the max_completion_tokens parameter if you wish to limit output. Note that the context window includes both input and output tokens, so ensure total tokens (input + output) do not exceed 400,000. The API will return errors if limits are exceeded.
If you currently use OpenAI's API directly, migrating to OrcaRouter requires changing only the base URL and API key. Replace openai.api_base from "https://api.openai.com/v1" to "https://api.orcarouter.ai/v1" and use your OrcaRouter API key. Keep all other code the same, including model names (e.g., "openai/gpt-5.2-2025-12-11") and request formats. The response structure is identical. Test with a single request to verify connectivity. OrcaRouter does not add any latency beyond what the provider delivers, and pricing is transparent (no markup). For users who need to switch models, the same endpoint works for all models available on OrcaRouter.
Authentication is via API key sent in the Authorization header: "Bearer <your-api-key>". You obtain an API key by creating an account on OrcaRouter and generating a key from the dashboard. There is no separate client ID or secret; the API key alone suffices. The key should be kept secure and not exposed in client-side code. For server-side applications, store it in environment variables. If you need multiple keys for different teams or projects, you can create multiple keys in the dashboard. All requests are billed to the account associated with the key. Rate limits and usage quotas are applied per key; consult OrcaRouter's documentation for specifics.
Compared to earlier GPT-4.0 models, GPT-5.2-2025-12-11 offers a significantly larger context window (400K vs typically 32K or 128K for GPT-4 Turbo), higher output limit (128K vs 8K-32K), and multimodal input support (GPT-4 Turbo also supports images, but GPT-5.2 adds file input). The AA Math score of 99.0 is likely much higher than GPT-4.0's typical performance on math benchmarks, which were around 70-80 on similar tests. Pricing is different: GPT-4 Turbo was $10/$30 per 1M tokens, while this model is cheaper for input ($1.75) but more expensive for output ($14). For tasks requiring less output, GPT-5.2 may be more cost-effective overall.
Claude models from Anthropic also offer large context windows (e.g., Claude 3.5 Sonnet has 200K). Claude 3.5 Opus has comparable math abilities but not a publicly reported AA Math score. GPT-5.2's 400K context is double that of most Claude models, and its 128K output is also larger than Claude's typical 4K-8K output. Pricing differences: Claude 3.5 Sonnet was $3/$15 per 1M tokens, while GPT-5.2 is $1.75/$14. So GPT-5.2 is cheaper on input but similar on output. Claude models have strong safety alignments and are often preferred for dialogue. The choice depends on specific task requirements, especially if you need the higher output capacity or math performance.
Open-source models like Llama 3.1 405B or Mixtral 8x22B have smaller context windows (typically 128K or less) and lower math benchmark scores. For example, Llama 3.1 405B scores around 85-90 on similar math tests. They cannot match GPT-5.2's 99.0 AA Math or its multimodal file input. However, open-source models can be self-hosted, offering lower per-token costs at scale if you have hardware. GPT-5.2 through OrcaRouter provides ease of use, zero infrastructure, and zero-markup pricing. For users who need maximum math accuracy, the closed-source model is superior; for those prioritizing cost control and data privacy via self-hosting, open-source may be preferable.
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.2-2025-12-11",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoningmax_completion_tokensmax_tokensreasoningresponse_formatseedstreamstructured_outputstool_choicetools| Input / 1M tokens | $1.75 |
| Output / 1M tokens | $14.00 |
| Cache read / 1M | $0.175 |
| 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.2-2025-12-11Open @misc{orcarouter_gpt_5_2_2025_12_11,
title = {openai/gpt-5.2-2025-12-11 API},
author = {openai},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/openai/gpt-5.2-2025-12-11}
}openai. (n.d.). openai/gpt-5.2-2025-12-11 API. OrcaRouter. https://www.orcarouter.ai/models/openai/gpt-5.2-2025-12-11