Zhipu (Z.ai) flagship open-source MoE: 355B total / 32B active. Hybrid reasoning (thinking / non-thinking modes), native tool calling and agentic surface, 128K context.
GLM-4.5 is a text-only language model by Z.ai, accessible via OrcaRouter's OpenAI-compatible API. It offers a 128,000-token context window and can output up to 96,000 tokens per request. The model is…
GLM-4.5 excels in tasks that involve mathematical reasoning, logical deduction, and step-by-step problem solving. It achieves a score of 97.9 on MATH-500, indicating high accuracy on a range of math problems. Other strong use cases include code generation and explanation, especially for algorithms and mathematical computations. The large context window (128K tokens) makes it suitable for processing long documents, such as research papers, legal texts, or technical manuals. Additionally, it can handle multi-turn conversations that involve referencing earlier parts of the conversation, provided the entire history fits within the 128K limit.
For simple tasks like straightforward classification, summarization of short texts, or basic question answering, a smaller model may be more cost-effective. GLM-4.5 is priced at $0.60 per 1M input tokens and $2.20 per 1M output tokens. If your application does not require the full 128K context or the strong mathematical reasoning, you might save costs by selecting a model with lower per-token pricing. Also, for multimodal applications (e.g., image captioning or video analysis), GLM-4.5 is not suitable because it only processes text. In those cases, consider models that support vision or audio inputs.
Yes, GLM-4.5 can generate code, especially for problems that involve mathematical computation or algorithmic logic. Its high MATH-500 score (97.9) suggests proficiency in reasoning over numeric and logical constructs, which translates to accurate code output in languages like Python, Java, or C++. The large context window allows the model to consider full codebases or long documentation while generating code. However, its primary strength is in reasoning rather than syntax-heavy tasks. For tasks that require deep knowledge of specific frameworks or libraries, a specialized code model might be more appropriate.
A 128K context window means GLM-4.5 can process up to roughly 96,000 words (or 128,000 subword tokens) in a single request. This is beneficial for tasks that involve long documents, extended conversations, or large-scale data analysis in one prompt. The model can maintain coherence across this long context, which is important for summarization, question answering over long texts, and multi-step reasoning. However, the actual effective context length may vary depending on the complexity of the content. Users should test with their specific use cases to ensure consistent performance at the upper end of the window.
MATH-500 is a benchmark consisting of 500 mathematics problems covering various difficulty levels, from basic arithmetic to advanced competition-level questions. A score of 97.9 means GLM-4.5 answered 97.9% of these problems correctly. This indicates very strong mathematical reasoning capability. The model likely employs rigorous step-by-step reasoning to arrive at answers. Users should note that this benchmark tests pure mathematical ability and may not reflect performance on other tasks such as creative writing or open-ended dialogue. It is a useful metric for evaluating models intended for STEM applications.
Exact speed and latency figures for GLM-4.5 are not publicly provided by Z.ai. Performance depends on factors such as request size, output length, network conditions, and server load. Through OrcaRouter, users can expect typical latency for a model of this size. As a text-only model with a 128K context, latency may increase proportionally with input length. Streaming is available to reduce perceived time to first token. For real-time applications, we recommend performing load tests with your typical workload. OrcaRouter's infrastructure is designed for reliable API access, but specific speed benchmarks should be measured in your own environment.
GLM-4.5's primary strength is mathematical reasoning, as demonstrated by its 97.9 score on MATH-500. It also handles long contexts (128K tokens) effectively, making it suitable for document-level tasks. The model can generate up to 96K tokens per output, which is useful for lengthy responses or multi-step reasoning chains. It is competitively priced for its performance tier. Additionally, it is accessed via OrcaRouter's OpenAI-compatible API, making integration straightforward for developers already familiar with that ecosystem. The model is text-only, which simplifies deployment when vision or audio are not required.
GLM-4.5 does not support any input modalities other than text. It cannot process images, audio, or video. Its training data and design focus on reasoning and mathematics; it may underperform on creative or subjective tasks compared to general-purpose models. The MATH-500 benchmark, while impressive, is a narrow evaluation: the model's performance on other benchmarks (e.g., coding, logic, factuality) is not provided. Also, like all large language models, it can produce errors or hallucinations, especially on ambiguous or out-of-distribution inputs. Users should validate outputs for critical applications. The large context window may increase latency and cost for very long prompts.
GLM-4.5 is priced at $0.60 per 1 million input tokens and $2.20 per 1 million output tokens. This is the provider rate from Z.ai, and OrcaRouter adds zero markup. Billing is usage-based: you pay only for tokens consumed. Input tokens include the prompt and any system messages; output tokens are generated by the model. A token is roughly 0.75 words in English. For a typical request with 10,000 input tokens and 5,000 output tokens, the cost would be (0.60 * 0.01) + (2.20 * 0.005) = $0.006 + $0.011 = $0.017. This transparent pricing allows for easy cost estimation.
Given its pricing structure, GLM-4.5 is most cost-effective for applications that benefit from its high mathematical reasoning and long context. For simple tasks, cheaper models may be sufficient, reducing operational costs. The 128K context window increases token usage per request, which can raise costs if not optimized. To manage expenses, consider truncating prompts to the necessary length and using output length limits. Also, since OrcaRouter charges no markup, the cost closely reflects provider pricing. Caching can further reduce costs if you reuse common prompt segments, but specific caching policies depend on your implementation with OrcaRouter.
OrcaRouter does not natively offer caching for GLM-4.5 requests. Caching is typically implemented on the client side. For example, you could store responses for identical prompts to avoid repeated billing. Alternatively, you can design your application to reuse context where possible. Since GLM-4.5 is billed per token, caching can significantly reduce costs for applications with high request volumes, especially if many requests share similar prefixes (e.g., system instructions). If you need server-side caching, consider using OrcaRouter's batch or prompt caching features if available—check their documentation for details.
GLM-4.5 supports up to 96,000 output tokens per request. This is unusually high and can lead to higher costs per request if you generate long responses. For instance, generating 96,000 output tokens would cost 96,000/1,000,000 * $2.20 = $0.2112 per request. While this allows for very long generations, it may be more economical to limit output length using the 'max_tokens' parameter unless the task truly requires long outputs. Budget-conscious users should set appropriate limits. The input and output token counts are summed and billed separately at their respective rates.
You access GLM-4.5 via OrcaRouter's OpenAI-compatible API. Set the base URL to https://api.orcarouter.ai/v1. Use the model ID "z-ai/glm-4.5" in your requests. The API accepts standard OpenAI parameters such as 'prompt', 'max_tokens', 'temperature', etc. For example, a chat completion call would use the endpoint /v1/chat/completions. Authentication requires an API key from OrcaRouter. The API behaves like the OpenAI API, so existing code can be easily migrated by changing the base URL and model name. Refer to OrcaRouter's documentation for authentication details.
Common parameters include: 'model' (set to "z-ai/glm-4.5"), 'messages' (list of dicts with role and content), 'max_tokens' (up to 96000), 'temperature' (controls randomness, default unspecified), 'top_p' (nucleus sampling), 'stream' (boolean), and 'stop' (sequences at which generation stops). GLM-4.5 supports the OpenAI chat completion format. Not all advanced parameters (like logprobs or tool calls) may be supported; test your use case. If you need to set frequency or presence penalties, consult OrcaRouter's documentation for compatibility. The model accepts system messages to set behavior.
Migration is straightforward. Update your code's base URL to https://api.orcarouter.ai/v1 and replace the model name with "z-ai/glm-4.5". Ensure you have a valid OrcaRouter API key. The request and response formats are identical to OpenAI's. No changes to prompt structure or parameters are needed unless you were using model-specific features not supported by OrcaRouter. Test with a small batch to confirm behavior. If you were using streaming, the same streaming endpoint works. OrcaRouter's documentation provides troubleshooting steps for common issues.
Rate limits and usage quotas for GLM-4.5 are determined by OrcaRouter based on your account tier. Typical rate limits are measured in requests per minute (RPM) and tokens per minute (TPM). For high-volume usage, you may need to request a higher limit. OrcaRouter's API returns standard HTTP status codes (e.g., 429 for rate limiting). It's recommended to implement exponential backoff in your client. There is no mention of strict quotas in the provided information; contact OrcaRouter support for specific limits. The model's context window and output length are per-request limits, not periodically enforced.
GLM-4.5 achieves a MATH-500 score of 97.9, placing it among top performers in mathematical reasoning. Many models score in the 80s or low 90s on this benchmark, so 97.9 is notably high. However, this comparison is limited to just one benchmark. On other metrics (e.g., general language understanding, coding), performance may differ. GLM-4.5 is text-only, while some competitors support vision. Its context window (128K) is larger than many models that offer 32K or 64K. Pricing is competitive for its tier. Users focused on mathematics may prefer GLM-4.5, but should evaluate on their specific tasks.
Cheaper models may have smaller context windows (e.g., 4K-8K) and lower benchmark scores. If your tasks are simple and require low latency, a cheaper model could be more cost-effective. For example, a model priced at $0.15/$0.60 per 1M tokens might be sufficient for basic summarization. GLM-4.5's advantage lies in its strong math reasoning and long context. The trade-off is higher cost per token. You should calculate the total cost for your typical usage pattern. If your application demands accurate mathematical reasoning or long documents, the higher cost may be justified.
Several providers offer models with similar context windows. GLM-4.5's pricing ($0.60/$2.20) is in the mid-to-moderate range. Some models with 128K context may be cheaper per token but have lower math scores. Others may be more expensive. GLM-4.5's MATH-500 score of 97.9 is exceptionally high. None of the provided facts mention other benchmark scores, so a full comparison is not possible. For users needing high math performance and long context, GLM-4.5 is a strong candidate. However, for creative writing or diversity, other models may be preferable. Always test with your specific data.
OrcaRouter provides a unified OpenAI-compatible API to access GLM-4.5 without managing infrastructure. Pricing is transparent with zero markup on provider rates. You get the same model as hosted by Z.ai, but through OrcaRouter's gateway which may offer additional features like load balancing, caching, or fallback options (check OrcaRouter's documentation). The API is standardized, so migrating to other models within the catalog is easy. OrcaRouter handles authentication and rate limits. If you already use other models on OrcaRouter, adding GLM-4.5 is just a model name change.
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="z-ai/glm-4.5",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)do_sampleinclude_reasoningmax_tokensreasoningrequest_idresponse_formatstopstreamtemperaturethinkingtool_choicetool_streamtoolstop_puser_id| Input / 1M tokens | $0.600 |
| Output / 1M tokens | $2.20 |
| Cache read / 1M | $0.110 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
@misc{orcarouter_glm_4_5,
title = {GLM 4.5 API},
author = {Z.ai},
year = {2025},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/z-ai/glm-4.5}
}Z.ai. (2025). GLM 4.5 API. OrcaRouter. https://www.orcarouter.ai/models/z-ai/glm-4.5