GLM 5.3 Flash (Refusals removed)
z-ai/glm-5.3-flash-abliteratedIndependentNo-retention policy: The provider's published policy says it keeps no prompts or replies. Zalmir can't check what happens on its machines.Refusals removed. It answers many requests the original model declines. The Terms explain what it may be used for.- Input / 1M
- $0.125
- Cached input / 1M
- $0.021
- Output / 1M
- $0.50
- Status
- Available
- Endpoints
- 1
Overview
A version of GLM 5.3 Flash, a mixture-of-experts model from Z.ai, with its refusal behavior removed (abliterated) by the independent provider that runs it. It answers many requests the original model declines. Text input only. The change was not made by Z.ai.
- Context (model)
- 1,048,576
- Max output (route)
- 65,536
- Input / output
- text → text
- Released
- Aug 25, 2026
Context (model) is the model author's published window. Max output (route) is the most this route returns: what the provider states, capped by Zalmir's max_tokens limit. Zalmir can't confirm the provider's stated limits.
Estimate a cost
Per request$0.000375Total$0.375
From the list price per 1M tokens. Activity shows the exact charge for every request.
Uptime and speed
- Uptime (30 days)
- 98.23%
- First token (typical)
- 0.58 s
- Output speed (typical)
- 54.2 tokens/s
| Day (UTC) | Requests answered |
|---|---|
| Nov 14, 2026 | 99.60% of 249 requests |
| Nov 15, 2026 | 99.03% of 207 requests |
| Nov 16, 2026 | 90.24% of 123 requests |
| Nov 17, 2026 | 100.00% of 121 requests |
| Nov 18, 2026 | 100.00% of 99 requests |
| Nov 19, 2026 | 100.00% of 50 requests |
Uptime is the share of real requests and Zalmir's own small test requests that got an answer, per UTC day; a day shows a figure once at least 20 requests were made. Typical speed is the median over the last 30 days: time to the first token, and output tokens per second from start to end. The status page shows the last 24 hours.
License
MIT License (of the base model, GLM 5.3 Flash), set by the model's author. The base model is under a permissive license: personal and commercial use are allowed. Keep the copyright notice when you redistribute it. The refusal-removed version was changed by the provider that runs it, not by Z.ai.
This summary is a reading aid; the linked license is what applies. Your use also has to follow Zalmir's acceptable use rules.
Providers
| Provider | Input $/1M | Cached input $/1M | Output $/1M | Context | Max output | Keeps prompts | Trains on prompts | Quantization | Uptime (24 h) | First token | Output speed |
|---|---|---|---|---|---|---|---|---|---|---|---|
| IndependentNo-retention policy: The provider's published policy says it keeps no prompts or replies. Zalmir can't check what happens on its machines. | $0.125 | $0.021 | $0.50 | 1,000,000 | 65,536 | No, per its policy | No, per the provider | FP8 | 100% | 0.81 s | 43.1 tokens/s |
Independent provider: The provider states it keeps no prompts or replies. Provider policies
How it runs. An independent provider runs this model on its own machines, not Zalmir's. Zalmir sends each request to it under Zalmir's own account with the provider, so the provider never receives your Zalmir API key or your IP address. The provider handles your prompt under its own published policy. HTTPS protects the request in transit, but there is no hardware attestation or end-to-end encryption to the model, so Zalmir can't check what happens on the provider's machines.
| Detail | Independent | Source |
|---|---|---|
| Quantization | FP8 | stated by the provider |
| Context (provider states) | 1,000,000 tokens | stated by the provider |
| Max output (provider states) | 128,000 tokens | stated by the provider |
| Zalmir's limits per request | Prompt up to 1,000,000 tokens; max_tokens up to 65,536 (a larger value is refused); request body up to 4 MiB | how Zalmir's gateway works |
| Request settings that work | max_tokens, max_completion_tokens, stream, response_format, structured_outputs, frequency_penalty, repetition_penalty, stop, logprobs, tools, tool_choice. n greater than 1 is not supported: Zalmir answers it with a 400 error before any hold, so nothing is charged. logit_bias is accepted; its effect could not be measured (Zalmir's test). | tested by Zalmir |
| Accepted but ignored by this provider | min_p, seed, temperature, top_k, top_p. presence_penalty could not be decided (repeats fell from 42 to 22, less than the test's halving), so it is listed neither way (Zalmir's test). | tested by Zalmir |
| Sampling settings (temperature, top_p, top_k and similar) | Accepted but ignored by the provider (Zalmir's test): with temperature 0, top_p 0.01, top_k 1, min_p 0.95 or seed 12345, two identical requests still gave different answers. Zalmir sends these settings to the provider unchanged. Z.ai evaluates it with temperature 1.0 and top_p 0.95. | checked by Zalmir |
| Reasoning | Thinks before answering. Its reasoning comes back with the answer (seen in Zalmir's tests). Its model card lists reasoning_effort low, high and max (default max). This provider lists no reasoning levels. | tested by Zalmir |
| Tokenizer | Other: GLM 5.3 Flash's own tokenizer (OpenRouter's family name: Other): removing refusals edits the weights only (the provider: "an edit, not a retrain"). | public model listings |
| Instruct format | None (uses the model's chat template): Z.ai's own template, shipped with the weights; OpenRouter also lists none for the original model. | public pages checked |
| Moderation | None added by Zalmir | how Zalmir's gateway works |
| Knowledge cutoff | Not published by Z.ai (checked its model card and API docs). Removing refusals adds no knowledge. | public pages checked |
| Provider location | Not published by the provider (checked its terms, privacy policy and models page); it says a GPU partner runs the models. | checked by Zalmir |
| Uptime (last 24 hours) | 100% of 109 requests | measured by Zalmir from real requests and its own test requests |
| Uptime (last 7 days) | 98.23% of 849 requests | measured by Zalmir from real requests and its own test requests |
| Time to first token (median, 24 hours) | 0.81 s | measured by Zalmir from real requests and its own test requests |
| Output speed (median, 24 hours, end to end) | 43.1 tokens/s | measured by Zalmir from real requests and its own test requests |
Sources: huggingface.co/zai-org/GLM-5.3-Flash; openrouter.ai/api/v1/models; docs.z.ai/guides/llm/glm-5.3-flash; and the provider's own model pages, terms and privacy policy (not linked: Zalmir does not name its providers).
Speed figures are medians of real requests and Zalmir's own small test requests, shown once at least 20 have been measured. The same details are in the endpoints API.
API
| Parameter | Type | Description |
|---|---|---|
max_tokens | integer | Zalmir stops answers at about that limit, streaming or not (output-event limit with a byte safety limit); a few extra tokens may arrive. Not exact token counting. |
max_completion_tokens | integer | Same Zalmir-enforced output limit, including reasoning and tools, streaming or not. Not exact token counting. |
stream | boolean | Return server-sent events when true. |
tools | array | Function definitions. Your application executes requested tools. |
response_format | object | JSON output: {"type": "json_object"} for valid JSON, or {"type": "json_schema", ...} to follow your schema. |
structured_outputs | via response_format | response_format with type json_schema (strict) is honored: the reply follows your JSON schema. |
curl https://zalmir.ai/api/v1/chat/completions \
-H "Authorization: Bearer $ZALMIR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "z-ai/glm-5.3-flash-abliterated", "stream": true,
"messages": [{"role": "user", "content": "Say hello."}]}'import os
from openai import OpenAI
client = OpenAI(
base_url="https://zalmir.ai/api/v1",
api_key=os.environ["ZALMIR_API_KEY"],
)
stream = client.chat.completions.create(
model="z-ai/glm-5.3-flash-abliterated",
messages=[{"role": "user", "content": "Say hello."}],
stream=True,
)
for chunk in stream:
if chunk.choices:
print(chunk.choices[0].delta.content or "", end="")import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://zalmir.ai/api/v1",
apiKey: process.env.ZALMIR_API_KEY,
});
const stream = await client.chat.completions.create({
model: "z-ai/glm-5.3-flash-abliterated",
messages: [{ role: "user", content: "Say hello." }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}package main
import (
"fmt"
"io"
"net/http"
"os"
"strings"
)
func main() {
url := "https://zalmir.ai/api/v1/chat/completions"
payload := strings.NewReader(`{
"model": "z-ai/glm-5.3-flash-abliterated",
"stream": true,
"messages": [{"role": "user", "content": "Say hello."}]
}`)
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("Authorization", "Bearer "+os.Getenv("ZALMIR_API_KEY"))
req.Header.Add("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(string(body))
}