--- title: "superbot clients" canonical_url: "https://superbot.gg/clients" summary: "Point your client at superbot and keep using it. Every setup below is three values: a base URL, a key and a model id." --- > Markdown of https://superbot.gg/clients. Site index: /llms.txt. # superbot clients Point your client at superbot and keep using it. Every setup below is three values: a base URL, a key and a model id. Mint a key on https://superbot.gg/account/api. Routes, limits and the error contract are on https://superbot.gg/developers. No account yet? Follow https://superbot.gg/auth.md: it signs the user in with an emailed code and gives you a token for `https://superbot.gg/mcp`. That token does not work on https://api.superbot.gg/v1. Mint the caller key with it: `curl -sS -X POST https://api.superbot.gg/v1/keys -H 'Authorization: Bearer sbk_…' -H 'content-type: application/json' -d '{"name":"YOUR NAME"}'` A 201 gives `{"key":"sbc_…","row":{…}}`. Keep the value of `key` now, because it is shown once. ## What to paste | what | value | | --- | --- | | Base URL | `https://api.superbot.gg/v1` | | key header | `Authorization: Bearer sbc_…` or `x-api-key` | | model ids | `superbot`: Your Superbot agent. `superbot-omni`: Superbot agent, run on your computer. | routing: your client -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits ## Keeping chats apart superbot keeps its server-side memory of a chat per conversation. Name a conversation with the `x-superbot-session: ` header: letters, digits, `_` and `-`, at most 59 characters. Every call that sends the same id continues the same thread, even when your client does not resend the earlier messages. With no header, superbot uses the conversation id your client already sends: `prompt_cache_key`, `metadata.session_id`, `metadata.conversation_id`, a Responses `conversation` or an Anthropic `metadata.user_id`. Codex and Claude Code send these, so the agent keeps each of their chats apart. With none of them, superbot keys the chat on its first message, so two chats that open with the same words share a thread. The OpenAI `user` field is not a conversation id. **curl with the session header** ``` curl https://api.superbot.gg/v1/chat/completions \ -H "Authorization: Bearer sbc_…" \ -H "x-superbot-session: my-chat-1" \ -H "Content-Type: application/json" \ -d '{"model": "superbot", "messages": [{"role": "user", "content": "ping"}]}' ``` The full rules are on https://superbot.gg/developers#conversations. ## Jump to a client - Cursor (#cursor) - Devin (#devin) - Claude Code (#claude-code) - Codex CLI (#codex) - GitHub Copilot (VS Code) (#copilot) - Continue (#continue) - Cline (#cline) - Roo Code (#roo) - Zed (#zed) - Aider (#aider) - OpenCode (#opencode) - Any OpenAI or Anthropic SDK (#sdk) ## Cursor (full) Cursor BYOK: key, base URL and custom model. routing: Cursor -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open `Cursor Settings`, then `Models`. 2. Paste your `sbc_` key into the `OpenAI API key` box. 3. Paste the base URL from the card above. 4. Put it in `Override OpenAI Base URL`. 5. Click `Add Custom Model` and name it `superbot`. 6. Add `superbot-omni` as a second custom model if you want it. 7. Select `superbot` in the model picker, then send one message. 8. With superbot relay: quit Cursor, run `superbot clients wire cursor`, skip 2-6. **what to paste** ``` Override OpenAI Base URL: https://api.superbot.gg/v1 OpenAI API key: sbc_… Custom model: superbot ``` **route it with superbot relay** ``` # quit Cursor first: it rewrites its state store on quit superbot clients wire cursor # what it puts in place for you Override OpenAI Base URL: https://api.superbot.gg/v1 OpenAI API key: sbc_… Custom models: superbot, superbot-omni # undo: restores the config it backed up superbot clients unwire cursor ``` **verify outside Cursor** ``` curl https://api.superbot.gg/v1/chat/completions \ -H "Authorization: Bearer sbc_…" \ -H "Content-Type: application/json" \ -d '{"model":"superbot","messages":[{"role":"user","content":"ping"}]}' ``` traps: - The override captures every OpenAI-family request it sees. That includes Cursor's own picker models, not just yours. Turn it off to send a picker model to its own vendor. - No Anthropic base override exists, so an Anthropic key stays native. Claude keeps working, billed by Anthropic as before. - The override must be a public URL: the dial comes from their servers. A `localhost` URL never answers. - Already pointing the override at another gateway? Keep it working. Add it on `/account/api` as `your previous upstream`. Its models then keep answering through superbot, in one key. - `superbot clients wire cursor` needs Cursor quit first, then writes the rows. Undo it with `superbot clients unwire cursor`. - Cursor may probe with `gpt-4o-mini` when you save the override. If that probe fails, the custom model can still work once selected. - The key lives in Cursor's own state store, not `settings.json`. - A request that declares its own tools is answered by the model driving them, and its tool calls come back for the client to run. Cards from the agent come back as plain markdown. - superbot keeps a server-side thread per conversation. When a Cursor request carries none of the conversation ids listed under `Keeping chats apart` at the top of this page, superbot keys the chat on its first message, so two Cursor chats that open with the same words share a thread. source: https://cursor.com/help/models-and-usage/api-keys, retrieved 2026-09-19 ## Devin (none) No custom endpoint, in the cloud or Desktop routing: Devin -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits Devin has no base URL to change, so it cannot be pointed at superbot. instead: 1. Devin takes no custom base URL, in the cloud or in Devin Desktop. 2. Use superbot's hosted MCP server instead. Devin connects to it as a remote MCP server, so it gets superbot's tools and keeps its own models. 3. For the Devin CLI, setup is the recipe at `/install/devin.md`: `devin mcp add -s user superbot` with the MCP URL, then `devin mcp login superbot`. 4. If a custom base URL ever appears, paste the same three values as any other client. traps: - "Devin is a compound AI system and does not currently support third-party LLM API keys." No tier exception is documented. - The Devin Desktop docs are silent on BYOK and base URLs. Desktop models come from the built-in catalog. source: https://docs.devin.ai/enterprise/deployment/overview, retrieved 2026-09-19 ## Claude Code (full) Claude Code BYOK: base URL, key, model. routing: Claude Code -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Set `ANTHROPIC_BASE_URL` to the base URL above. 2. Set `ANTHROPIC_API_KEY`, which is sent as `x-api-key`. 3. Or set `ANTHROPIC_AUTH_TOKEN`, sent as `Authorization: Bearer`. 4. Pick the model with `ANTHROPIC_MODEL` or `--model`. 5. Set `CLAUDE_CODE_MAX_CONTEXT_TOKENS` to the window the snippet prints for that model. 6. You can also set `model` in `settings.json`. Or put all of it in the `"env"` block there. 7. Restart Claude Code, then send one message. **shell setup** ``` export ANTHROPIC_BASE_URL="https://api.superbot.gg/v1" export ANTHROPIC_API_KEY="sbc_…" export ANTHROPIC_MODEL="superbot" export CLAUDE_CODE_MAX_CONTEXT_TOKENS="1000000" ``` **settings.json** ``` { "env": { "ANTHROPIC_BASE_URL": "https://api.superbot.gg/v1", "ANTHROPIC_API_KEY": "sbc_…", "ANTHROPIC_MODEL": "superbot", "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "1000000" } } ``` traps: - Claude Code assumes a 200K window for a model id that does not start with `claude-`. `CLAUDE_CODE_MAX_CONTEXT_TOKENS` gives it the window superbot serves. - A non-first-party base URL turns MCP tool search off. Set `ENABLE_TOOL_SEARCH=true` to force it on. - Remote Control is disabled on a non-first-party base URL. - The base URL only changes where requests go. It does not choose the model. - Send `superbot` as the model id. Claude Code declares its own tools, so superbot answers with the model driving them: its tool calls come back for Claude Code to run, on your machine. Cards from the agent come back as plain markdown. - `/model` beats `--model` and `ANTHROPIC_MODEL`. Both beat the `settings.json` model. - Claude Code puts its session id in `metadata.user_id`, so when your agent answers, superbot keeps each Claude Code session in its own thread. Do not set one fixed `x-superbot-session` header for it: a fixed value would put every session in one thread. source: https://code.claude.com/docs/en/llm-gateway, retrieved 2026-09-19 ## Codex CLI (full) Codex CLI: custom provider in config.toml. routing: Codex CLI -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open `~/.codex/config.toml`, and create it if it is missing. 2. Add a `[model_providers.superbot]` table. 3. Give it `base_url`, `env_key` and `wire_api`. 4. Set `wire_api = "responses"`, the only value Codex still supports. 5. Export `SUPERBOT_API_KEY` with a caller key. That is the name `env_key` points at. 6. Set the top-level `model_provider`, `model` and `model_context_window` keys, above the table, then restart Codex. **config.toml** ``` model_provider = "superbot" model = "superbot" model_context_window = 1000000 [model_providers.superbot] name = "superbot" base_url = "https://api.superbot.gg/v1" env_key = "SUPERBOT_API_KEY" wire_api = "responses" ``` **the env key** ``` export SUPERBOT_API_KEY="sbc_…" ``` traps: - `wire_api` only takes `responses`. The old `chat` value was removed. - These keys are ignored in a project-local `.codex/config.toml`. Write them in the user one. - A custom provider id cannot be `openai`, `ollama` or `lmstudio`. Keep the id `superbot`. - superbot serves `/v1/responses`, so the responses wire is what answers. - Codex declares its own tools, so `superbot` answers with the model driving them: its tool calls come back for Codex to run, on your machine. Cards from the agent come back as plain markdown. - The provider `name` is only a label. The top-level `model_provider` is what selects it. - Keep `model_provider`, `model` and `model_context_window` above the `[model_providers.superbot]` table. A key below a table header belongs to that table. - superbot answers Codex's own model-list request (`GET /v1/models?client_version=…`) with `superbot`, `superbot-omni` and `superbot-fast`, so Codex knows their efforts, their windows and the Fast option. A Codex that cannot read that list prints `Model metadata for superbot not found. Defaulting to fallback metadata` on the first request. Requests still go through. `model_context_window` gives Codex the window superbot serves in place of its generic default. - `superbot` and `superbot-omni` serve the efforts `none`, `low`, `high`, `xhigh` and `max`, and run at `high`, their default, when you set none. A `medium` is served as `low`, `minimal` as `low` and `ultra` as `max` (`xhigh` is its own level). `superbot-fast` runs at `low` (or `none`). Set `model_reasoning_effort` at the top level to pick one. - For Fast, set `service_tier = "priority"` at the top level: superbot serves the turn with priority, at twice the price. - Codex sends its conversation id as `prompt_cache_key`, so when your agent answers, superbot keeps each Codex chat in its own thread. Do not add an `x-superbot-session` value under `http_headers`: one fixed value would put every Codex chat in one thread. source: https://learn.chatgpt.com/docs/config-file/config-reference, retrieved 2026-09-19 ## GitHub Copilot (VS Code) (partial) Chat works via a `Custom Endpoint` provider. routing: GitHub Copilot (VS Code) -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open the model picker in chat and select `Manage Language Models`. 2. Select `Add Models`, then `Custom Endpoint`, and name the group. 3. Enter your key from `/account/api`. 4. Then choose the API type: `Chat Completions`, `Responses`, `Messages`. 5. VS Code opens `chatLanguageModels.json`. Paste the snippet below into it and save. 6. The snippet gives the full URL. 7. Select the model in the picker. Restart VS Code if it does not show up. **chatLanguageModels.json** ``` [ { "name": "superbot", "vendor": "customendpoint", "apiKey": "sbc_…", "models": [ { "id": "superbot", "name": "superbot", "url": "https://api.superbot.gg/v1/chat/completions", "apiType": "chat-completions", "toolCalling": true } ] } ] ``` traps: - BYOK covers chat only. Semantic search, inline suggestions and embeddings are not covered. - A Copilot Business or Enterprise admin controls this. It is the `Bring Your Own Language Model Key in VS Code` policy. - The server-side Enterprise BYOK preview needs the Completions API. A `responses` model will not work there. - A raw `apiKey` committed to the file is a leaked key. The docs use an `${input:myApiKey}` variable instead. source: https://code.visualstudio.com/docs/copilot/customization/language-models, retrieved 2026-09-19 ## Continue (full) One OpenAI provider entry in `config.yaml`. routing: Continue -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open `config.yaml`. 2. Under `models:` add one entry, or edit the one already there. 3. Set `provider: openai` and `apiBase` to the base URL above. 4. Set `apiKey` to your `sbc_` caller key. 5. Set `model` to `superbot`, and give the entry a `name`. 6. Save, reload the extension, then send a chat message. **config.yaml** ``` models: - name: superbot provider: openai apiBase: https://api.superbot.gg/v1 apiKey: sbc_… model: superbot useResponsesApi: false ``` **verify outside Continue** ``` curl https://api.superbot.gg/v1/chat/completions \ -H "Authorization: Bearer sbc_…" \ -H "Content-Type: application/json" \ -d '{"model":"superbot","messages":[{"role":"user","content":"ping"}]}' ``` traps: - `config.json` is deprecated. Write `config.yaml` instead. - The Anthropic provider entry has no `apiBase` field. Use the openai provider with the same `apiBase`. - Without `useResponsesApi: false` Continue may call the Responses API. source: https://docs.continue.dev/customize/model-providers/top-level/openai, retrieved 2026-09-19 ## Cline (full) Either dialect, three fields to fill in. routing: Cline -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open Cline and click the settings gear. 2. Set `API Provider` to `OpenAI Compatible`. 3. Paste the base URL above into `Base URL`. 4. Paste your `sbc_` caller key into `API Key`. 5. Type your model id into `Model`, or pick it from the list. 6. Type the context window from the card into the model's `Context Window` field. 7. Send one message and confirm the reply arrives. **what to paste** ``` Base URL: https://api.superbot.gg/v1 API Key: sbc_… Model: superbot Context window: 1000000 ``` traps: - The base URL is not `https://api.openai.com/v1`. That holds even with the OpenAI Compatible provider selected. - A wrong model id answers `Model Not Found`. - Left empty, `Context Window` makes Cline assume 128K tokens for a model it does not know. - For the Anthropic provider, tick `Use custom base URL`. Paste the same base URL into that field. - One caller key serves both providers. source: https://docs.cline.bot/provider-config/openai-compatible, retrieved 2026-09-19 ## Roo Code (partial) Two providers; tool calling unverified. routing: Roo Code -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open Roo Code settings. 2. Set `API Provider` to `OpenAI Compatible`. 3. Paste the base URL above into `Base URL`. 4. Paste your `sbc_` caller key into `API Key`. 5. Set `Model` to your model id, or pick it from the list. 6. Type the context window from the card into the model's `Context Window` field. 7. Send a message and read the reply. **what to paste** ``` Base URL: https://api.superbot.gg/v1 API Key: sbc_… Model: superbot Context window: 1000000 ``` traps: - Roo sends native tool calls on every request. - Not verified here: whether the agent lane answers those tool calls. - A wrong model id answers `Model Not Found`. - Left empty, `Context Window` makes Roo assume 128K tokens for a model it does not know. - The base URL is not `https://api.openai.com/v1`. - For the Anthropic provider, tick `Use custom base URL`. Paste the same base URL into that field. source: https://docs.roocode.com/providers/openai-compatible, retrieved 2026-09-19 ## Zed (full) settings.json plus a key in the keychain. routing: Zed -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open `settings.json`. 2. Add a `language_models.openai_compatible` block. 3. Set its `api_url` to the base URL above. 4. List the model in `available_models` with `name` and `max_tokens`. 5. Store your `sbc_` key in Agent Settings, or set `SUPERBOT_API_KEY`. 6. Pick the model in the assistant panel, then send a message. **settings.json** ``` { "language_models": { "openai_compatible": { "superbot": { "api_url": "https://api.superbot.gg/v1", "available_models": [ { "name": "superbot", "display_name": "superbot", "max_tokens": 1000000 } ] } } } } ``` **api key** ``` export SUPERBOT_API_KEY="sbc_…" ``` traps: - `max_tokens` is required. It is the context window, and the example sets the window superbot serves for the model. - The key never goes into `settings.json`. Use Agent Settings or the env var. - The env var is the provider id uppercased, plus `_API_KEY`. - `chat_completions` already defaults to `true`. No extra field is needed for that. - For the Anthropic dialect, use `anthropic_compatible`. Give it the same `api_url`. source: https://zed.dev/docs/ai/use-api-access, retrieved 2026-09-19 ## Aider (full) Aider via `openai/`: base URL and key. routing: Aider -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Export `OPENAI_API_BASE` with the base URL above. 2. Export `OPENAI_API_KEY` with a caller key. 3. Run `aider --model openai/superbot`. 4. Use `--openai-api-base` instead of the env var if you prefer flags. 5. Send one prompt to confirm the route. **shell setup** ``` export OPENAI_API_BASE="https://api.superbot.gg/v1" export OPENAI_API_KEY="sbc_…" aider --model openai/superbot ``` traps: - The `openai/` prefix on the model id is required. Without it, another provider is picked. - An unknown model id still runs, but Aider prints model warnings. - `OPENAI_API_BASE` and `--openai-api-base` carry the same value. - Aider speaks OpenAI chat, so it dials `/v1/chat/completions`. source: https://aider.chat/docs/llms/openai-compat.html, retrieved 2026-09-19 ## OpenCode (full) OpenCode: add superbot as a provider. routing: OpenCode -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Open your `opencode.json`. 2. Add a `provider.superbot` entry. 3. Set its `npm` to `@ai-sdk/openai-compatible`. 4. Set `options.baseURL` to the base URL above, then give it an `options.apiKey`. 5. List each model id under `models`, keyed by the id itself, with its `limit` and `variants` as in the snippet. 6. Restart OpenCode and send one message. **opencode.json** ``` { "provider": { "superbot": { "npm": "@ai-sdk/openai-compatible", "name": "superbot", "options": { "baseURL": "https://api.superbot.gg/v1", "apiKey": "sbc_…" }, "models": { "superbot": { "name": "Superbot", "reasoning": true, "limit": { "context": 1000000, "output": 131072 }, "variants": { "none": { "reasoningEffort": "none" }, "low": { "reasoningEffort": "low" }, "high": { "reasoningEffort": "high" }, "xhigh": { "reasoningEffort": "xhigh" }, "max": { "reasoningEffort": "max" } } } } } } } ``` traps: - Model ids must match an id from `GET /v1/models`. Use `superbot`. - Without `limit.context`, OpenCode assumes a 200K window for the model. The snippet sets the window superbot serves. - Keep `limit.output` beside `limit.context`. OpenCode rejects a `limit` that has only one of them. - Each `variants` entry is one effort superbot serves for that model, sent as `reasoningEffort`. - The `apiKey` in the file is a plain secret. `/connect` keeps it out of the repo. - A provider needs `@ai-sdk/openai-compatible` for the OpenAI wire. - OpenCode reads providers at start, so restart after every edit. source: https://opencode.ai/docs/providers/, retrieved 2026-09-19 ## Any OpenAI or Anthropic SDK (full) Any OpenAI or Anthropic SDK, same base URL. routing: Any OpenAI or Anthropic SDK -> superbot (https://superbot.gg) -> your vendor keys | your previous upstream | the superbot agent / credits 1. Install the `openai` or `anthropic` package for your language. 2. Set `OPENAI_BASE_URL` or `ANTHROPIC_BASE_URL` in the environment. 3. Pass a caller key as the API key, or put it in the matching env var. 4. Send a normal request with the model id shown in the env comment. 5. Swap that id for the omni one to run the agent on your computer. 6. Send an `x-superbot-session` header to keep one chat in its own server-side thread. Use a different id for each chat. **env, both dialects** ``` export OPENAI_BASE_URL="https://api.superbot.gg/v1" export OPENAI_API_KEY="sbc_…" export ANTHROPIC_BASE_URL="https://api.superbot.gg/v1" export ANTHROPIC_API_KEY="sbc_…" # model: superbot for your agent, superbot-omni to run it on your computer ``` **python: openai** ``` from openai import OpenAI c = OpenAI(base_url="https://api.superbot.gg/v1", api_key="sbc_…") r = c.chat.completions.create(model="superbot", messages=[{"role": "user", "content": "ping"}]) print(r.choices[0].message.content) ``` **python: anthropic** ``` from anthropic import Anthropic c = Anthropic(base_url="https://api.superbot.gg/v1", api_key="sbc_…") m = c.messages.create(model="superbot", max_tokens=256, messages=[{"role": "user", "content": "ping"}]) print(m.content[0].text) ``` **python: name a conversation** ``` from openai import OpenAI c = OpenAI(base_url="https://api.superbot.gg/v1", api_key="sbc_…") r = c.chat.completions.create( model="superbot", messages=[{"role": "user", "content": "ping"}], extra_headers={"x-superbot-session": "my-chat-1"}, ) print(r.choices[0].message.content) ``` **curl** ``` curl https://api.superbot.gg/v1/chat/completions \ -H "Authorization: Bearer sbc_…" \ -H "Content-Type: application/json" \ -d '{"model": "superbot", "messages": [{"role": "user", "content": "ping"}]}' ``` traps: - `ANTHROPIC_AUTH_TOKEN` is sent as `Authorization: Bearer`. - `ANTHROPIC_API_KEY` is sent as `x-api-key`. - One base URL for both SDKs. It ends in `/v1`. - Do not repeat `/v1` on the request path. - The Node OpenAI client reads `OPENAI_BASE_URL` by default. A `baseURL` you pass wins. - Pass `base_url=` to the Anthropic Python constructor. - The `user` field is not a conversation id. Name the chat with `x-superbot-session`, or send `prompt_cache_key` or `metadata.session_id`. With none, superbot keys the chat on its first message. source: https://developers.openai.com/api/reference/python, retrieved 2026-09-19