What is UncensoredLabs?
UncensoredLabs provides hosted access to uncensored and abliterated DeepSeek and GLM text models through an OpenAI-compatible API. Existing OpenAI-compatible clients can generally connect by changing their base URL, supplying an UncensoredLabs application API key, and selecting an exact model ID.
The service can also be used through the browser Chat. The public GitHub repository contains guides, configuration examples, and API samples; it does not contain the hosted platform implementation or model weights.
Important: “Abliterated” means that a model's weights have been modified to reduce refusal behavior. It does not guarantee correct answers or eliminate refusals for every prompt.
Key features
- OpenAI-compatible API: Keep a compatible client and point it to the UncensoredLabs base URL.
- DeepSeek and GLM models: Choose among six listed uncensored or abliterated model variants.
- Large context: Every model in the documented catalog has a one-million-token context window, subject to the provider's context accounting.
- Text streaming: All six catalog entries support incremental text generation.
- Function tools: Every listed model supports function tools for application and agent workflows.
- Multiple integration paths: The repository includes Python, TypeScript, streaming, and coding-client examples.
- Usage-based billing: Input, cached-input, and output rates are published per one million tokens.
Before you begin
Create an account through the UncensoredLabs signup page. In the dashboard, create an application API key.
Do not place the 16-digit account sign-in key in API requests. The account sign-in key and the application API key are different credentials.
Eligible new accounts receive $0.10 in trial credits. Repeat-trial signals may require identity verification, and prepaid top-ups begin at $3. Because the API reserves credit before generation, confirm that the dashboard shows enough available balance for your chosen model and request.
Set up your API key
For Linux or macOS, export the application API key in your shell:
export UNCENSOREDLABS_API_KEY="YOUR_APPLICATION_API_KEY"This keeps the credential outside the request body and lets the shell substitute it into the authorization header. Avoid committing API keys to source control, examples, logs, or public GitHub issues.
For platform-specific environment setup, including PowerShell instructions, consult the quickstart guide.
Send your first chat completion
No client library is required for a basic request. The following command calls the OpenAI-compatible chat completions endpoint with curl:
curl --fail-with-body https://uncensoredlabs.dev/v1/chat/completions \
-H "Authorization: Bearer $UNCENSOREDLABS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-v4.1-flash-1017-abliterated",
"messages": [
{
"role": "user",
"content": "Review this security design: customer comments are rendered as HTML in an admin console. Explain the attack path and how to verify the fix."
}
],
"max_tokens": 1024
}'The request has four essential parts:
- Endpoint:
https://uncensoredlabs.dev/v1/chat/completions. - Authorization: A bearer token containing the application API key.
- Model: An exact model ID from the live catalog.
- Messages: An array of role-and-content objects describing the conversation.
The max_tokens value limits the requested output. It must remain within the selected model's output limit, while the combined input and output must fit its context accounting.
Choose a model
The README records the following catalog snapshot as checked on November 1, 2026. Prices are in US dollars per one million tokens before any active plan discount. Rates, health, and availability can change, so the live API catalog takes precedence.
deepseek-v4-pro-uncensored: $0.50 input, $0.10 cached input, and $0.50 output; maximum output 65,536 tokens.deepseek-v4.1-flash-1017-abliterated: $0.30 input, $0.12 cached input, and $0.30 output; maximum output 65,536 tokens.deepseek-v4.1-flash-abliterated: $0.30 input, $0.10 cached input, and $0.30 output; maximum output 65,536 tokens.deepseek-v4.1-flash-abliterated-fast: $1.40 input, $0.32 cached input, and $1.40 output; maximum output 65,536 tokens.glm-5.3-abliterated: $1.40 input, $0.40 cached input, and $1.40 output; maximum output 130,000 tokens.glm-5.3-uncensored: $0.35 input, $0.10 cached input, and $0.35 output; maximum output 65,536 tokens.
All six entries support text, streaming, and function tools, and each has a one-million-token context window. Catalog inclusion does not guarantee that a model is currently healthy. Review the repository's model catalog guide for live links, limits, pricing, performance information, and measurement limitations.
Adapt the request for your workflow
Keep the endpoint and authorization headers unchanged, then replace the model, prompt, and token limit. For example, a reverse-engineering request can ask a model to explain a decompiled routine:
{
"model": "glm-5.3-uncensored",
"messages": [
{
"role": "user",
"content": "Explain this decompiled routine, identify its data structures, and describe how you would validate your interpretation."
}
],
"max_tokens": 2048
}Documented use cases include security research, reverse engineering, developer tooling, creative work, and trust-and-safety evaluations. Models can help analyze trust boundaries, compare vulnerable code with patches, recover file-format structures, create labeled evaluation cases, and investigate moderation failure modes.
Use Python and TypeScript clients
Because the service is OpenAI-compatible, it is intended to work with compatible clients after changing the base URL, API key, and model selection. The repository includes a runnable Python example using the OpenAI SDK with automatic retries disabled.
A separate TypeScript example demonstrates an OpenAI SDK request with typed error handling. Start from these maintained samples rather than assuming that every OpenAI API feature or client behavior is supported identically.
For details about the supported protocol and content handling, read the compatibility and privacy guide.
Stream generated text
Streaming lets an interface process generated text incrementally rather than waiting for the complete response. UncensoredLabs provides dedicated documentation covering incremental text, usage events, and failures that can occur after a stream has begun.
- Read the streaming guide before implementing event processing.
- Use the runnable Python streaming example as a starting point.
- Use the TypeScript streaming example for a TypeScript integration.
A robust streaming interface should distinguish incremental content from usage information and stream failures instead of treating every event as generated text.
Connect coding clients
The repository provides configuration guidance for Cline, Continue, and OpenCode. In each case, use the documented UncensoredLabs base URL, an application API key, and an exact model ID supported by the live catalog.
Follow the coding clients guide for client-specific configuration rather than exposing credentials in project files.
Advanced operational tips
Check live health and availability
A model appearing in the catalog does not mean it is currently healthy. Check the live catalog and model details when selecting a model or diagnosing failures. Avoid hard-coding assumptions based only on the repository snapshot.
Plan for credit reservations
Requests reserve credit before generation. A positive but small account balance may still be insufficient for a model's reservation. If a request is rejected, check the available balance and the selected model's pricing before retrying.
Handle failures deliberately
Use curl --fail-with-body during command-line testing so HTTP failures are visible without discarding the response body. For production integrations, consult the errors and billing guide for HTTP errors, rate limits, reservations, and retry decisions.
Do not retry every failure automatically. The repository's Python example explicitly disables automatic retries, while the TypeScript example demonstrates typed error handling. Your application should decide whether a failure is temporary and whether retrying could duplicate work or consume additional resources.
Respect context and output limits
The one-million-token context includes both input and output under the provider's accounting. Set max_tokens according to the task and the selected model's maximum output. Most listed models allow up to 65,536 output tokens, while glm-5.3-abliterated allows up to 130,000.
Validate model output
Reduced refusal behavior is not a guarantee of accuracy. Verify security findings, reverse-engineering conclusions, generated code, and evaluation labels with appropriate tests and human review. The security research guide contains concrete prompts for analysis and evaluation workflows.
Protect sensitive information
Keep application keys, account details, payment information, and vulnerability details out of public issues. Use public issues only for reproducible documentation problems and example improvements, and follow the repository's support and security reporting instructions for sensitive matters.
Conclusion
UncensoredLabs offers one OpenAI-compatible endpoint for hosted uncensored and abliterated DeepSeek and GLM text models. Create an application API key, verify your balance, send a chat completion to /v1/chat/completions, and select an exact model ID from the live catalog. From there, use the maintained Python, TypeScript, streaming, coding-client, and error-handling guides to build a more robust integration.
The repository's original documentation and example code are MIT licensed. That license does not cover the hosted platform source, model weights, provider services, or third-party trademarks. UncensoredLabs is an independent service and is not affiliated with OpenAI, DeepSeek, or Zhipu AI.