Uncensored · Privacy first · OpenAI-compatible

Uncensored models. Zero chat logs.

Open-weight models with the refusals removed. Point Claude Code, Codex or any OpenAI-compatible tool at one base URL. Conversations are not stored and code is not scanned. Prepaid per token, no subscription.

  • Uncensored models
  • Zero chat logs
  • No ID required
  • USDT / USDC accepted

In public beta. Sign up with a verified email address. Telegram support @newbeeai

Open code you can audit

The gateway and billing code is public under AGPL-3.0. Anyone can check it line by line.

  • No hidden token overhead
  • No billing traps
  • No quietly weakened models
  • No cheap model sold as an expensive one
Read the source

Your conversations are not stored

We keep only what billing needs: account sign-up, top-ups and token usage.

  • Prompts and context are not saved
  • Documents and codebases are not scanned
  • Request content is not written to logs

What you send is up to you. Keep your own prompts and code safe.

Open, uncensored models

Every model listed is an open-weight, uncensored model that we have tuned ourselves.

  • Far fewer refusals
  • No loss of capability
  • Open weights only

No ID, no KYC

An email address is all it takes to sign up, and you can pay in crypto.

  • No phone number, no documents
  • No KYC checks
  • Pay in USDT or USDC, 1:1 with USD

We do not ask who you are, and we do not keep what you say.

Command-line tools and code: copy the config.

shell
export ANTHROPIC_BASE_URL=https://api.6bee.ai
export ANTHROPIC_AUTH_TOKEN=<your key>
export ANTHROPIC_MODEL=<model id>
export ANTHROPIC_DEFAULT_HAIKU_MODEL=<model id>   # background tasks
claude
config.toml
# ~/.codex/config.toml, then: export SIXBEE_API_KEY=<your key>
model = "<model id>"
model_provider = "sixbee"

[model_providers.sixbee]
name = "6bee"
base_url = "https://api.6bee.ai/v1"
env_key = "SIXBEE_API_KEY"
wire_api = "responses"
opencode.jsonc
// ~/.config/opencode/opencode.jsonc, then: export SIXBEE_API_KEY=<your key>
{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "sixbee": {
      "name": "6bee.ai",
      "env": ["SIXBEE_API_KEY"],
      "package": "@opencode/ai/providers/openai-compatible",
      "settings": { "baseURL": "https://api.6bee.ai/v1" },
      "models": {
        // set limit to the model's caps (see Limits)
        "<model id>": { "limit": { "context": 128000, "output": 16384 } }
      }
    }
  },
  "model": "sixbee/<model id>"
}
shell
curl https://api.6bee.ai/v1/chat/completions \
  -H "Authorization: Bearer $SIXBEE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "<model id>", "stream": true, "max_tokens": 2048,
       "messages": [{"role": "user", "content": "Write a unit test for fizzbuzz"}]}'
app.py
from openai import OpenAI   # pip install openai

client = OpenAI(base_url="https://api.6bee.ai/v1", api_key="<your key>")
reply = client.chat.completions.create(
    model="<model id>", max_tokens=2048,
    messages=[{"role": "user", "content": "Explain this stack trace"}])
print(reply.choices[0].message.content)

GUI apps: fill in the settings.

Desktop apps like Cherry Studio and Chatbox, and editor agents like Cline, add 6bee as an OpenAI-compatible provider.

Cherry Studio Settings Model Provider Add

Provider Name
6bee.ai
Provider Type
OpenAI
API Host
https://api.6bee.ai Cherry Studio adds /v1 itself; don’t type it.
API Key
<your key>
Models
Pull the list with Manage, or use Add Model with a model ID.

Click Check, and make sure the provider is switched on.

Chatbox Settings Model Provider Add

Name
6bee.ai
API Mode
OpenAI API Compatible
API Host
https://api.6bee.ai/v1
API Path
Leave empty (defaults to /chat/completions).
API Key
<your key>
Models
Fetch the list, or add one with New and a model ID.

Save, then click Check.

Cline Settings ⚙ API Provider

API Provider
OpenAI Compatible
Base URL
https://api.6bee.ai/v1
API Key
<your key>
Model ID
<model id>
Model Configuration
Set Context Window Size and Max Output Tokens to the model’s caps (see Limits).

Roo Code works the same way: pick OpenAI Compatible and enter the same URL, key and model.

Any other OpenAI-compatible tool: base URL https://api.6bee.ai/v1, plus your key and a model ID.

Signed in? In the console’s Chat menu, pick Cherry Studio, DeepChat or another app to import the address and your key in one click. Open the console

Three API formats. One host.

Use the format your tool already speaks. One key, one balance, one set of limits.

Anthropic Messages

For Claude Code and the Anthropic SDK.

POST /v1/messages

Base URL
https://api.6bee.ai

Auth with x-api-key or a Bearer token. Errors come back in Anthropic’s format.

OpenAI Responses

For Codex.

POST /v1/responses

Base URL
https://api.6bee.ai/v1

Send the full input each turn. store, previous_response_id and WebSocket mode are not supported.

OpenAI Chat Completions

For OpenCode, Cherry Studio, Cline and OpenAI SDKs.

POST /v1/chat/completions

Base URL
https://api.6bee.ai/v1

Auth with a Bearer token. List models with GET /v1/models.

All three stream over server-sent events.

Up and running in three steps.

  1. Sign up

    Create an account with a verified email address.

    Create an account
  2. Top up and create a key

    Add prepaid balance, then create a key under API keys. Keep it secret.

  3. Point your tool here

    Set the base URL and your key in the tool. The quickstart and GUI apps sections above have the exact values.

Sized for long agent sessions.

Beta limits apply per account, across all of its keys.

Context
Input plus output up to the model’s window: 128K to 1M tokens, depending on the model.
Output
max_tokens up to the model’s output cap: 16,384 to 131,072, depending on the model. Larger values are lowered to the cap, not rejected. If omitted: 8,192 to 32,768.
Input tokens
1,000,000 uncached tokens per rolling minute. Cache hits don’t count.
Requests
60 per minute.
Concurrency
2 requests at a time.
Request body
Up to 8 MiB. n must be 1.

Over a limit you get HTTP 429 with Retry-After, or 400 when a request can’t fit the context. A lowered output cap is reported in the X-6bee-Output-Cap response header; on /v1/messages a thinking budget is lowered with it.

Questions, answered.

What is 6bee.ai?

6bee.ai is a prepaid API for open-weight, uncensored large language models. You point Claude Code, Codex or any OpenAI-compatible tool at one base URL, https://api.6bee.ai, and pay per token from a prepaid balance. There is no subscription.

It is aimed mainly at coding tools and AI agents, so the limits are sized for long sessions.

What does “uncensored” mean on 6bee.ai?

Every model listed is an open-weight model that has been tuned to remove refusals. In practice it refuses far fewer requests than a mainstream assistant, without losing capability.

It does not mean anything goes. The Acceptable Use rules apply regardless of what a model is willing to generate. See what uncensored means here.

Do you store my conversations?

No. Prompts, context and completions are not saved, documents and codebases are not scanned, and request content is not written to logs. They pass through our systems only to be forwarded to the model and returned to you.

What we do keep is what billing needs: your account, your top-ups and per-request usage metadata (model, token counts, cost, time, IP address, status). See what is and is not stored.

Do I need to verify my identity?

No. Sign-up takes an email address and a CAPTCHA check. We do not ask for your real name, a phone number or identity documents, and we run no KYC checks. You can also pay in USDT or USDC.

How do I pay?

You top up a prepaid balance in the console. You can pay by bank card (processed by Stripe; we never see the card number) or in USDT or USDC. Prices are in US dollars.

What are the rate limits?

During the beta, per account across all of its keys: 60 requests per minute, 2 requests at a time, and 1,000,000 uncached input tokens per rolling minute (cache hits do not count). A request body can be up to 8 MiB.

All questions

Prepaid. Billed per token.

Your balance is charged per token at each model’s price. Each request first reserves its input plus max_tokens of output; when it finishes you pay for what was used, and the rest goes back to your balance.