How to Use GLM 5.3 Abliterated and Uncensored Models Through a Compatible API

What you will learn

This tutorial explains how to access GLM 5.3 variants through 7API, configure the API for OpenAI- and Anthropic-compatible clients, and evaluate the results in real coding, reasoning, bilingual, and agent workflows.

The repository also includes a collection of system prompts, AGENTS.md files, workspace policies, and Ollama Modelfiles. These files can be used with compatible clients, but prompt behavior is version-dependent and should be tested rather than assumed.

Understand the terminology

GLM 5.3 abliterated generally refers to a weight-level modification intended to reduce the model's refusal direction. GLM 5.3 uncensored is a broader label for a model variant that refuses less often, whether the result comes from abliteration, fine-tuning, data choices, model merges, or another alignment recipe.

The terms are related but are not identical. Neither label guarantees that a model will answer every request. Behavior depends on the exact model version, prompt, provider policy, and instruction hierarchy.

• Abliterated: usually describes a model-weight modification.
• Uncensored: describes a broader reduction in refusal behavior.
• Standard GLM 5.3: may provide a different balance of safety behavior, quality, and cost.

Why use GLM 5.3?

GLM 5.3 belongs to Zhipu AI's GLM family and is intended for coding, agent workflows, reasoning, and bilingual Chinese and English tasks. It can be useful when you need repository-scale instructions, tool-using workflows, cost-sensitive processing, or another model family in your routing mix.

Through 7API, the same account and API key can also provide access to other model families, including Claude, GPT, Gemini, Grok, DeepSeek, and Kimi, with variants listed according to current availability.

• Use compatible APIs instead of rewriting an application for every model provider.
• Test GLM 5.3 for coding and tool-oriented workflows.
• Compare standard, abliterated, and uncensored variants on your own tasks.
• Use pay-per-token access and check live pricing in the dashboard.

Set up API access

1. Create an account and obtain credentials

Create an account at 7api.st. Copy the API key and the appropriate base URL from the dashboard. Keep the key in an environment variable rather than placing it directly in source code.

export SEVEN_API_KEY="sk-..."
export SEVEN_API_BASE_URL="https://.../v1"

The Anthropic-compatible endpoint may use a base URL shown separately in the dashboard, so use the value provided for the client you are configuring.

2. Choose the exact model ID

Open the dashboard and copy the current model ID for the GLM 5.3 variant you want. Do not assume that a placeholder or an older identifier will remain valid. Availability can change between model versions.

For the examples below, replace GLM_5_3_MODEL_ID with the exact ID from the dashboard.

Send an OpenAI-compatible request

Install the OpenAI Python SDK in your project, then initialize the client with the 7API key and base URL.

pip install openai

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["SEVEN_API_KEY"],
    base_url=os.environ["SEVEN_API_BASE_URL"],
)

response = client.chat.completions.create(
    model="GLM_5_3_MODEL_ID",
    messages=[
        {"role": "system", "content": "You are a precise coding assistant."},
        {
            "role": "user",
            "content": "Refactor this function and explain the trade-offs: ...",
        },
    ],
)

print(response.choices[0].message.content)

This pattern uses the familiar chat-completions interface. You can adapt the system and user messages to coding, bilingual writing, analysis, or agent tasks supported by your client.

Send an Anthropic-compatible request

If your application uses the Anthropic SDK, install it and configure the compatible base URL from the dashboard.

pip install anthropic

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["SEVEN_API_KEY"],
    base_url=os.environ["SEVEN_API_BASE_URL"],
)

message = client.messages.create(
    model="GLM_5_3_MODEL_ID",
    max_tokens=1024,
    system="You are a precise coding assistant.",
    messages=[
        {"role": "user", "content": "Write a migration plan for this module."}
    ],
)

print(message.content[0].text)

Use the Anthropic-compatible base URL specified by 7API if your dashboard provides a separate endpoint for this protocol.

Connect developer tools

The repository documents compatibility with several development environments. The general process is to provide the appropriate endpoint, API key, and GLM 5.3 model ID in the tool's provider configuration.

• Claude Code: point ANTHROPIC_BASE_URL at the 7API Anthropic endpoint.
• Cursor: add a custom OpenAI-compatible provider.
• OpenCode: add a custom provider and the selected GLM 5.3 model ID.
• Codex CLI: use an OpenAI-compatible provider profile.
• LangChain or LlamaIndex: use the OpenAI-compatible adapter.

For client-specific instructions, consult the repository's Claude Code, Cursor, OpenCode, and Codex guide.

Use the repository's prompt files

The repository contains prompt files for GLM, Claude, DeepSeek, Kimi, Grok, OpenCode, Ollama, and other environments. Select the format that matches your client rather than pasting every file into a normal conversation.

• System prompts: copy the file contents into a system message or custom-instructions field.
• AGENTS.md files: save the file in the root of the repository or workspace when the coding agent supports project-level instructions.
• Workspace policies: place them in the persistent instruction location required by your client. For example, the README notes ~/.config/opencode/AGENTS.md for an OpenCode installation.
• Ollama Modelfiles: pass the file to Ollama, for example ollama create gemma4-jb -f gemma4.md.
• Grok configuration: use grok-config.txt in the target harness's configuration field, not as an ordinary chat message.

Prompt behavior can change when models, instruction hierarchies, or client versions are updated. Treat these files as experiments and verify their behavior on the exact model release you use.

Evaluate a GLM 5.3 variant

A single successful response is not enough to determine whether an abliterated or uncensored model is suitable for production. Build a repeatable test set containing representative tasks and compare variants under the same conditions.

1. Measure refusal rate: test prompts that previously failed and record whether the model completes, partially completes, or declines each task.
2. Measure quality: evaluate real coding, reasoning, translation, and bilingual writing tasks.
3. Check side effects: look for changes in tone, instruction following, structured output, and tool use.
4. Track version drift: repeat the tests whenever the provider changes a model or model ID.
5. Calculate cost per successful task: include retries and failed attempts rather than comparing token prices alone.

The repository provides a dedicated evaluation checklist for this process.

Advanced usage and operational tips

Keep model selection configurable

Store the model ID in configuration or an environment variable so you can compare standard, abliterated, and uncensored variants without changing application code. Always verify the current ID in the dashboard before deployment.

Use separate project credentials

7API supports subkeys, which can help separate budgets for projects, teammates, or clients. Apply the smallest practical permissions and rotate credentials if they are exposed.

Monitor cached input and retries

The service uses pay-per-token billing and supports a lower cached-input rate where supported. Track retries, prompt size, and successful task completion so that a cheaper model does not become more expensive through repeated failures.

Compare the wider catalog

Because one key can cover multiple model families, evaluate GLM 5.3 alongside Claude, GPT, Gemini, Grok, DeepSeek, and Kimi when routing quality, latency, language performance, or refusal behavior matters. The uncensored AI API model catalog provides a broader comparison starting point.

Responsible use and limitations

Abliterated and uncensored variants are not guaranteed to be refusal-free. Reduced refusal behavior can also change instruction following, tone, or other quality characteristics. Add application-level guardrails, logging, access controls, and human review when outputs affect people, systems, or important decisions.

• Follow applicable laws, provider terms, and organizational policies.
• Do not treat a model label as a safety or quality guarantee.
• Test the exact version and provider endpoint you plan to use.
• Protect API keys and avoid exposing them in client-side applications or repositories.
• Review generated code and agent actions before applying them to production systems.

See the repository's safety and responsible use guide for additional considerations.

Pricing and availability

7API uses pay-per-token access rather than a subscription. The README also lists cached-input billing where supported, crypto top-ups using BTC, ETH, USDT, and LTC, subkeys, and a referral program. Check the dashboard for current GLM 5.3 pricing, limits, and availability because these details and model entries can change.

Conclusion

To use GLM 5.3 through 7API, create an account, copy the correct key and base URL, select the exact model ID from the dashboard, and connect through the OpenAI or Anthropic SDK. You can then integrate the model with coding tools and evaluate it against real workloads. Treat abliterated and uncensored labels as descriptions of reduced refusal behavior, not promises, and re-test whenever the model version changes.

For the complete reference, continue with the repository's GLM 5.3 API quickstart and troubleshooting documentation.