Source: https://ailoot.ai/integrations/
Canonical: https://ailoot.ai/integrations/en/
Language: en

[Integrations](https://ailoot.ai/docs/en/integrations/) 

# Connect Ailoot to your favorite tools — AI API connections and client setup

Agents, editors, chats, and SDKs that accept an Ailoot key. The “Set up” button shows where to enter the URL and key, with a ready-to-copy configuration.

**85**applications

**77**ready

**8**under review

 Search applications 

## Terminal agents

Coding agents and CLIs: write code, run commands, and edit files.

CC

### [Claude Code](https://ailoot.ai/docs/en/integrations/claude-code/)

Terminal agent

Anthropic Messages

Anthropic’s terminal agent: writes code, edits files, and runs commands.

[Learn more →](https://ailoot.ai/docs/en/integrations/claude-code/)

#### Where to set it up

Environment variables or the "env" block in ~/.claude/settings.json (for a single project, .claude/settings.local.json); VS Code extension — claudeCode.environmentVariables; check with the /status command

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.claude/settings.json`

```json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.ailoot.ai",
    "ANTHROPIC_MODEL": "claude-sonnet-5-5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-5-5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-5-5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5",
    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY": "1"
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
export ANTHROPIC_AUTH_TOKEN="$AILOOT_API_KEY"
claude
```

Example model: `claude-sonnet-5-5`

#### Important

Use a URL without /v1: Claude Code adds /v1/messages itself. ANTHROPIC\_AUTH\_TOKEN is sent as Authorization: Bearer, ANTHROPIC\_API\_KEY as x-api-key; Ailoot accepts both. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 loads our models into /model through /v1/models. For 400 errors about unknown fields, use CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. Anthropic's documentation does not support using Claude Code with non-Claude models through a gateway, although our /v1/messages endpoint serves them; we recommend Claude models. Remote Control and voice input are unavailable when using a gateway.

[Full guide →](https://ailoot.ai/docs/en/integrations/claude-code/)[Application documentation ↗](https://code.claude.com/docs/en/llm-gateway-connect)

OC

### [OpenAI Codex CLI](https://ailoot.ai/docs/en/integrations/openai-codex-cli/)

Terminal agent

OpenAI Responses

OpenAI’s terminal agent, using the Responses format.

[Learn more →](https://ailoot.ai/docs/en/integrations/openai-codex-cli/)

#### Where to set it up

~/.codex/config.toml (the user-level file only: model\_provider/model\_providers are ignored in a project’s .codex/config.toml); the key goes in the variable named by env\_key

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/responses, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.codex/config.toml`

```toml
model = "gpt-6.1-sol"
model_provider = "ailoot"

[model_providers.ailoot]
name = "Ailoot"
base_url = "https://api.ailoot.ai/v1"
env_key = "AILOOT_API_KEY"
wire_api = "responses"
```

```bash
export AILOOT_API_KEY="sk-..."
codex
```

Example model: `gpt-6.1-sol`

#### Important

Codex uses only the OpenAI Responses API: the documentation lists only wire\_api = "responses", so it needs our /v1/responses. Provider IDs openai, ollama, and lmstudio are reserved. Alternatively, use openai\_base\_url = "https://api.ailoot.ai/v1" with the built-in openai provider. Ailoot returns the model list in Codex manifest format through GET /v1/models with client\_version. Choose a specific model whose catalog entry lists OpenAI Responses. In the 2026-09-30 snapshot, gemini-3.6-flash has OpenAI Chat, Anthropic Messages, and Gemini, but no Responses, so it is unsuitable for Codex. Check formats on the model card, not from the family name.

[Full guide →](https://ailoot.ai/docs/en/integrations/openai-codex-cli/)[Application documentation ↗](https://learn.chatgpt.com/docs/config-file/config-advanced)

HA

### [Hermes Agent](https://ailoot.ai/docs/en/integrations/hermes-agent/)

Terminal agent

OpenAI ChatOpenAI ResponsesAnthropic Messages

Nous Research’s terminal agent with memory and skills.

[Learn more →](https://ailoot.ai/docs/en/integrations/hermes-agent/)

#### Where to set it up

hermes model → “Custom endpoint (self-hosted / VLLM / etc.)” or ~/.hermes/config.yaml (the model section or providers dictionary)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.hermes/config.yaml`

```yaml
model:
  default: claude-sonnet-5-5
  provider: custom
  base_url: https://api.ailoot.ai/v1
  key_env: AILOOT_API_KEY

# multiple formats at once: named providers:
providers:
  ailoot:
    api: https://api.ailoot.ai/v1
    key_env: AILOOT_API_KEY
    transport: chat_completions
    default_model: gpt-6.1-sol
  ailoot-claude:
    api: https://api.ailoot.ai
    key_env: AILOOT_API_KEY
    transport: anthropic_messages
    default_model: claude-sonnet-5-5

# in the session: /model custom:claude-sonnet-5-5
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

transport: chat\_completions (OpenAI Chat), anthropic\_messages (Anthropic Messages), or codex\_responses (OpenAI Responses). LLM\_MODEL in .env is no longer used; OPENAI\_BASE\_URL applies only to the openai-api provider. For anthropic\_messages, use a URL without /v1; the Anthropic SDK appends /v1/messages. Auxiliary tasks (image recognition, history compaction) use the same main model by default.

[Full guide →](https://ailoot.ai/docs/en/integrations/hermes-agent/)[Application documentation ↗](https://hermes-agent.nousresearch.com/docs/integrations/providers)

Op

### [OpenClaw](https://ailoot.ai/docs/en/integrations/openclaw/)

Terminal agent

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

A personal AI assistant on your computer for chats, messaging, and tasks.

[Learn more →](https://ailoot.ai/docs/en/integrations/openclaw/)

#### Where to set it up

OpenClaw configuration (~/.openclaw/openclaw.json) → models.providers.\<id\>; the default model is agents.defaults.model.primary; a safe update is openclaw config set models.providers.\<id\> '\<json\>' --strict-json --merge

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ailoot/claude-sonnet-5-5"
      }
    }
  },
  "models": {
    "mode": "merge",
    "providers": {
      "ailoot": {
        "baseUrl": "https://api.ailoot.ai/v1",
        "apiKey": "${AILOOT_API_KEY}",
        "api": "openai-completions",
        "models": [
          {
            "id": "claude-sonnet-5-5",
            "name": "Claude Sonnet 5.5",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 128000
          },
          {
            "id": "deepseek-v4-pro",
            "name": "DeepSeek V4 Pro",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 131072
          }
        ]
      },
      "ailoot-claude": {
        "baseUrl": "https://api.ailoot.ai",
        "apiKey": "${AILOOT_API_KEY}",
        "api": "anthropic-messages",
        "models": [
          {
            "id": "claude-opus-5-5",
            "name": "Claude Opus 5.5",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 131072
          }
        ]
      }
    }
  }
}
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

api adapters include openai-completions (the default when baseUrl is set), openai-responses (only if the server supports /v1/responses, which Ailoot does), anthropic-messages, and google-generative-ai. OpenClaw’s anthropic-messages examples use baseUrl without /v1. OpenClaw can send images when the model’s input includes "image". The Claude examples keep text only: the 2026-09-30 catalog snapshot does not declare image input for these methods. Add "image" only for a specific model whose current catalog card declares image input in the selected API format. For example, gemini-3.6-flash declares image input for OpenAI Chat in that snapshot; actual support depends on the model card and format. The main configuration path follows common OpenClaw practice; the page reviewed also mentions ~/.openclaw/agents/\<agentId\>/agent/models.json.

[Full guide →](https://ailoot.ai/docs/en/integrations/openclaw/)[Application documentation ↗](https://docs.openclaw.ai/gateway/config-tools/custom-providers)

Op

### [opencode](https://ailoot.ai/docs/en/integrations/opencode/)

Terminal agent

OpenAI Chat

An open-source terminal agent for any OpenAI-compatible provider.

[Learn more →](https://ailoot.ai/docs/en/integrations/opencode/)

#### Where to set it up

opencode.json in the project or ~/.config/opencode/opencode.json → provider.\<id\>; set the key through /connect or "apiKey": "{env:VAR}"

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "ailoot/claude-sonnet-5-5",
  "provider": {
    "ailoot": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ailoot",
      "options": {
        "baseURL": "https://api.ailoot.ai/v1",
        "apiKey": "{env:AILOOT_API_KEY}"
      },
      "models": {
        "claude-sonnet-5-5": {
          "name": "Claude Sonnet 5.5"
        },
        "gpt-6.1-sol": {
          "name": "GPT-6.1 Sol"
        },
        "deepseek-v4-pro": {
          "name": "DeepSeek V4 Pro"
        }
      }
    }
  }
}
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

The @ai-sdk/openai-compatible package calls /v1/chat/completions. For models that require /v1/responses, opencode documentation specifies @ai-sdk/openai. A custom Anthropic-compatible provider with baseURL is not described in opencode’s documentation. Choose models whose current catalog entry lists OpenAI Chat. In the 2026-09-30 snapshot, gemini-3.6-flash has that format; check other Gemini models on their cards. This path does not use native Gemini format. A catalog method listing does not establish a live test of a specific client version.

[Full guide →](https://ailoot.ai/docs/en/integrations/opencode/)[Application documentation ↗](https://opencode.ai/docs/providers/)

QC

### [Qwen Code](https://ailoot.ai/docs/en/integrations/qwen-code/)

Terminal agent

OpenAI ChatAnthropic MessagesGemini

Qwen’s command-line agent, supporting OpenAI, Anthropic, and Gemini formats.

[Learn more →](https://ailoot.ai/docs/en/integrations/qwen-code/)

#### Where to set it up

OPENAI\_API\_KEY / OPENAI\_BASE\_URL / OPENAI\_MODEL variables, /auth inside the session, or ~/.qwen/settings.json (modelProviders + security.auth.selectedType)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
export AILOOT_API_KEY="sk-..."
# quick method
export OPENAI_API_KEY="$AILOOT_API_KEY"
export OPENAI_BASE_URL=https://api.ailoot.ai/v1
export OPENAI_MODEL=qwen3.8-max
qwen
```

`~/.qwen/settings.json`

```json
{
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3.8-max",
        "name": "Qwen 3.8 Max (Ailoot)",
        "envKey": "AILOOT_API_KEY",
        "baseUrl": "https://api.ailoot.ai/v1"
      },
      {
        "id": "claude-sonnet-5-5",
        "name": "Claude Sonnet 5.5 (Ailoot)",
        "envKey": "AILOOT_API_KEY",
        "baseUrl": "https://api.ailoot.ai/v1"
      }
    ]
  },
  "security": {
    "auth": {
      "selectedType": "openai"
    }
  },
  "model": {
    "name": "qwen3.8-max"
  }
}
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `qwen3.8-max`

#### Important

Protocol types: openai (Chat Completions), anthropic, gemini, and vertex-ai. For openai, include /v1 in baseUrl. The documentation examples for anthropic and gemini do not include baseUrl, so we recommend the openai option. For the openai type, choose a model whose catalog entry lists OpenAI Chat; gemini-3.6-flash has that format. Other Gemini models may support different formats, so check the specific model card. The settings.json option reads the key from AILOOT\_API\_KEY through envKey. Set it with export AILOOT\_API\_KEY=sk-... or an AILOOT\_API\_KEY=sk-... line in ~/.qwen/.env; otherwise, Qwen Code starts with an empty key and receives 401.

[Full guide →](https://ailoot.ai/docs/en/integrations/qwen-code/)[Application documentation ↗](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/)

GC

### [Gemini CLI](https://ailoot.ai/docs/en/integrations/gemini-cli/)

Terminal agent

Gemini

Google’s terminal agent using native Gemini format.

[Learn more →](https://ailoot.ai/docs/en/integrations/gemini-cli/)

#### Where to set it up

GEMINI\_API\_KEY and GOOGLE\_GEMINI\_BASE\_URL environment variables; authentication method: ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; model: GEMINI\_MODEL or the -m flag

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
export AILOOT_API_KEY="sk-..."
export GEMINI_API_KEY="$AILOOT_API_KEY"
export GOOGLE_GEMINI_BASE_URL=https://api.ailoot.ai
export GEMINI_MODEL=gemini-3.8-flash
gemini
```

`~/.gemini/settings.json`

```json
{
  "security": {
    "auth": {
      "selectedType": "gemini-api-key"
    }
  }
}
```

Example model: `gemini-3.8-flash`

#### Important

Use an address without /v1beta: the SDK appends /v1beta/models/{model}:generateContent automatically. The address must use HTTPS. The key is sent in the x-goog-api-key header, which Ailoot accepts. Only models listed with the Gemini format in the catalog are suitable. Before running a request, check that the exact ID and this method are available to your key. Ailoot delivers paid Gemini responses in full after calculating the cost, not word by word, so text takes longer to appear for long responses.

[Full guide →](https://ailoot.ai/docs/en/integrations/gemini-cli/)[Application documentation ↗](https://geminicli.com/docs/reference/configuration/)

KC

### [Kimi CLI](https://ailoot.ai/docs/en/integrations/kimi-cli/)

Terminal agent

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Moonshot’s command-line coding agent.

[Learn more →](https://ailoot.ai/docs/en/integrations/kimi-cli/)

#### Where to set it up

~/.kimi/config.toml (providers and models sections, default\_model); /login supports only Moonshot platforms, so set a custom URL manually in the file

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.kimi/config.toml`

```toml
default_model = "ailoot-kimi"

[providers.ailoot]
type = "openai_legacy"
base_url = "https://api.ailoot.ai/v1"
api_key = "sk-..."

[providers.ailoot-claude]
type = "anthropic"
base_url = "https://api.ailoot.ai"
api_key = "sk-..."

[models.ailoot-kimi]
provider = "ailoot"
model = "kimi-k3"
max_context_size = 262144
capabilities = ["thinking"]

[models.ailoot-sonnet]
provider = "ailoot-claude"
model = "claude-sonnet-5-5"
max_context_size = 1000000
capabilities = ["thinking", "image_in"]
```

Example model: `kimi-k3`

#### Important

Types: openai\_legacy (Chat Completions, base\_url with /v1), openai\_responses (Responses, with /v1), anthropic (without /v1), gemini (base\_url is Google's root URL; for us, https://api.ailoot.ai). SearchWeb works only with Moonshot's own platform; with a different API URL, FetchURL switches to local downloading.

[Full guide →](https://ailoot.ai/docs/en/integrations/kimi-cli/)[Application documentation ↗](https://moonshotai.github.io/kimi-cli/en/configuration/providers.html)

Cr

### [Crush](https://ailoot.ai/docs/en/integrations/crush/)

Terminal agent

OpenAI ChatAnthropic Messages

Charm’s terminal agent, configured through crushrc.

[Learn more →](https://ailoot.ai/docs/en/integrations/crush/)

#### Where to set it up

crushrc (Bash configuration): ./.crushrc, ./crushrc, or ~/.config/crush/crushrc; the legacy crush.json format is deprecated but still works

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.config/crush/crushrc`

```bash
export AILOOT_API_KEY="sk-..."
provider add ailoot --type openai-compat \
  --base-url "https://api.ailoot.ai/v1" \
  --api-key "$AILOOT_API_KEY"

model add ailoot/deepseek-v4-pro \
  --name "DeepSeek V4 Pro (Ailoot)" \
  --context-window 1000000 \
  --default-max-tokens 32000

# Anthropic format for Claude: URL without /v1
provider add ailoot-claude --type anthropic \
  --base-url "https://api.ailoot.ai" \
  --api-key "$AILOOT_API_KEY"

model add ailoot-claude/claude-sonnet-5-5 \
  --name "Claude Sonnet 5.5 (Ailoot)" \
  --context-window 1000000 \
  --default-max-tokens 64000 \
  --can-reason true --supports-images false
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `deepseek-v4-pro`

#### Important

The openai-compat type uses the OpenAI Chat format and a URL with /v1. The anthropic type uses the Messages format and a URL without /v1: Crush passes it to anthropic-sdk-go, which appends /v1/messages. The example in the Crush README with /v1 would produce /v1/v1/messages and a 404 error. The key is sent in the x-api-key header, which Ailoot accepts. If the model list is empty, the openai-compat provider fetches it from /v1/models. crushrc runs as code: do not launch Crush in someone else's directory containing this file. In this example, Claude has supports-images = false: the 2026-09-30 catalog snapshot lists only text for the selected Messages format. If your version of Crush supports this flag, enable it only for a model whose current catalog card lists image input in the selected API format; the client flag alone does not add image support to a model.

[Full guide →](https://ailoot.ai/docs/en/integrations/crush/)[Application documentation ↗](https://github.com/charmbracelet/crush#custom-providers)

Ai

### [Aider](https://ailoot.ai/docs/en/integrations/aider/)

Terminal agent

OpenAI Chat

AI pair programming directly in a git repository.

[Learn more →](https://ailoot.ai/docs/en/integrations/aider/)

#### Where to set it up

Environment variables OPENAI\_API\_BASE and OPENAI\_API\_KEY; the --model openai/\<model\> flag

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
export AILOOT_API_KEY="sk-..."
export OPENAI_API_BASE=https://api.ailoot.ai/v1
export OPENAI_API_KEY="$AILOOT_API_KEY"
aider --model openai/deepseek-v4-pro
```

Example model: `openai/deepseek-v4-pro`

#### Important

The openai/ prefix is required: it tells Aider (through LiteLLM) to send requests to the OpenAI-compatible /v1/chat/completions endpoint. For models Aider does not recognize, it will warn that the context window is unknown — this is not an error. This documentation page does not cover an Anthropic endpoint with a custom base URL.

[Full guide →](https://ailoot.ai/docs/en/integrations/aider/)[Application documentation ↗](https://aider.chat/docs/llms/openai-compat.html)

Go

### [Goose](https://ailoot.ai/docs/en/integrations/goose/)

Terminal agent

OpenAI ChatAnthropic Messages

An open-source terminal and desktop agent with MCP extensions.

[Learn more →](https://ailoot.ai/docs/en/integrations/goose/)

#### Where to set it up

goose configure → Custom Providers → Add A Custom Provider, or JSON in ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); alternatively, use the built-in OpenAI provider with OPENAI\_HOST/OPENAI\_BASE\_PATH

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.config/goose/custom_providers/ailoot.json`

```json
{
  "name": "ailoot",
  "engine": "openai",
  "display_name": "Ailoot",
  "description": "Ailoot API",
  "api_key_env": "AILOOT_API_KEY",
  "base_url": "https://api.ailoot.ai/v1/chat/completions",
  "models": [
    {
      "name": "claude-sonnet-5-5",
      "context_limit": 1000000
    },
    {
      "name": "gpt-6.1-sol",
      "context_limit": 272000
    }
  ],
  "supports_streaming": true,
  "requires_auth": true
}
```

```bash
export AILOOT_API_KEY="sk-..."
goose session start --provider ailoot

# alternative using the built-in OpenAI provider:
export GOOSE_PROVIDER=openai
export OPENAI_HOST=https://api.ailoot.ai
export OPENAI_BASE_PATH=v1/chat/completions
export OPENAI_API_KEY="$AILOOT_API_KEY"
```

Example model: `claude-sonnet-5-5`

#### Important

Custom provider engines: openai, anthropic, ollama. In the Goose example, base\_url for engine openai includes the full path to /v1/chat/completions. For the built-in provider, OPENAI\_HOST is the root URL without a path, and OPENAI\_BASE\_PATH is the path (v1/chat/completions by default). Goose ignores keys in config.yaml; use an environment variable or the keyring. The repository has moved to aaif-goose/goose.

[Full guide →](https://ailoot.ai/docs/en/integrations/goose/)[Application documentation ↗](https://github.com/aaif-goose/goose/blob/main/documentation/docs/getting-started/providers.md)

FD

### [Factory Droid](https://ailoot.ai/docs/en/integrations/factory-droid/)

Terminal agent

OpenAI ChatOpenAI ResponsesAnthropic Messages

Factory’s terminal agent with custom models.

[Learn more →](https://ailoot.ai/docs/en/integrations/factory-droid/)

#### Where to set it up

~/.factory/settings.json → customModels array; select a model with the /model command under “Custom models”

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "customModels": [
    {
      "model": "claude-sonnet-5-5",
      "displayName": "Claude Sonnet 5.5 (Ailoot)",
      "baseUrl": "https://api.ailoot.ai",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "anthropic",
      "maxOutputTokens": 64000
    },
    {
      "model": "gpt-6.1-sol",
      "displayName": "GPT-6.1 Sol (Ailoot)",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "openai",
      "maxOutputTokens": 64000
    },
    {
      "model": "deepseek-v4-pro",
      "displayName": "DeepSeek V4 Pro (Ailoot)",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "generic-chat-completion-api",
      "maxOutputTokens": 32000
    }
  ]
}
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

provider: anthropic = Messages API (baseUrl as for Anthropic, without /v1), openai = Responses API (with /v1), generic-chat-completion-api = Chat Completions (with /v1). For anthropic, the key is sent in x-api-key by default (Ailoot accepts it); "authMode": "bearer" switches to Authorization. Keys remain local. Factory fully tests only the official Anthropic and OpenAI APIs.

[Full guide →](https://ailoot.ai/docs/en/integrations/factory-droid/)[Application documentation ↗](https://docs.factory.com/model-independence/byok)

Am

### [Amp](https://ailoot.ai/docs/en/integrations/amp/)

Terminal agent

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Amp coding agent with flexible model routing.

[Learn more →](https://ailoot.ai/docs/en/integrations/amp/)

#### Where to set it up

Settings → Model Routing → Add → Custom URL (or workspace Model Routing for a team); from the terminal — amp config model-providers (list, test, set-priority, edit-router…)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Model Routing → Add → Custom URL
  Format:   anthropic-messages
  Base URL: https://api.ailoot.ai
  API key:  sk-...
  Model mapping:
    anthropic/claude-fable-5 -> anthropic/claude-fable-5

Second connection for GPT:
  Format:   responses
  Base URL: https://api.ailoot.ai/v1
  API key:  sk-...
  Model mapping:
    openai/gpt-5.6-sol -> gpt-5.6-sol

Check: amp config model-providers check-access --provider-model anthropic/claude-fable-5
```

Example model: `claude-fable-5`

#### Important

Custom URL formats: chat-completions (\<base\>/chat/completions), responses (\<base\>/responses), anthropic-messages (\<base\>/v1/messages; /v1 is not duplicated), google-genai (\<base\>/models/\<model\>:streamGenerateContent). The key is sent as Authorization: Bearer. Mappings use canonical Amp IDs in the provider/model form; the arrow specifies the ID sent to us. Amp handles models not covered by the connection itself, using its own credits. The documentation requires the custom host to be accessible from Amp — our URL is public, so this requirement is met.

[Full guide →](https://ailoot.ai/docs/en/integrations/amp/)[Application documentation ↗](https://ampcode.com/docs/markdown/customize/model-routing)

AI

### [AIChat](https://ailoot.ai/docs/en/integrations/aichat/)

Terminal agent

OpenAI ChatAnthropic MessagesGemini

A general-purpose terminal chat with roles, sessions, and RAG.

[Learn more →](https://ailoot.ai/docs/en/integrations/aichat/)

#### Where to set it up

AIChat config.yaml → clients (types openai-compatible, claude, gemini); model: -m \<client\>:\<model\>

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```yaml
clients:
  - type: openai-compatible
    name: ailoot
    api_base: https://api.ailoot.ai/v1
    api_key: sk-...
    models:
      - name: deepseek-v4-pro
        max_input_tokens: 1000000
        supports_function_calling: true
  - type: claude
    api_base: https://api.ailoot.ai/v1
    api_key: sk-...
  - type: gemini
    api_base: https://api.ailoot.ai/v1beta
    api_key: sk-...
```

```bash
aichat -m ailoot:deepseek-v4-pro 'Hello'
```

Example model: `deepseek-v4-pro`

#### Important

In AIChat's example configuration, api\_base for claude includes /v1, while gemini uses /v1beta; use the same paths for Ailoot. The three clients provide access to all three Ailoot formats: OpenAI, Anthropic, and Gemini.

[Full guide →](https://ailoot.ai/docs/en/integrations/aichat/)[Application documentation ↗](https://github.com/sigoden/aichat/blob/main/config.example.yaml)

CC

### [Continue CLI](https://ailoot.ai/docs/en/integrations/continue-cli/)

Terminal agent

OpenAI Chat

Continue’s command-line version for agents and automation.

[Learn more →](https://ailoot.ai/docs/en/integrations/continue-cli/)

#### Where to set it up

Continue YAML configuration (config.yaml), passed to the CLI with --config \<path\>

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`ailoot.yaml`

```text
name: Ailoot
version: 0.0.1
schema: v1
models:
  - name: Claude Sonnet 5.5 (Ailoot)
    provider: openai
    model: claude-sonnet-5-5
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...

# run:
cn --config ./ailoot.yaml
```

Example model: `claude-sonnet-5-5`

#### Important

For OpenAI-compatible services, Continue uses provider: openai and an apiBase with /v1. The configuration format is shared by the extension and CLI; pass the file with the --config flag.

[Full guide →](https://ailoot.ai/docs/en/integrations/continue-cli/)[Application documentation ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Fo

### [ForgeCode](https://ailoot.ai/docs/en/integrations/forge/)

Terminal agent

OpenAI Chat

A terminal agent with configurable providers.

[Learn more →](https://ailoot.ai/docs/en/integrations/forge/)

#### Where to set it up

forge provider login → OpenAI-compatible (recommended); the deprecated option uses .env with OPENAI\_URL and OPENAI\_API\_KEY, plus model in forge.yaml

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
# recommended:
forge provider login   # select OpenAI-compatible, enter https://api.ailoot.ai/v1 and sk-...

# legacy method (.env):
OPENAI_API_KEY=sk-...
OPENAI_URL=https://api.ailoot.ai/v1

# forge.yaml
model: claude-sonnet-5-5
```

Example model: `claude-sonnet-5-5`

#### Important

Configuration through .env is marked as deprecated: on first launch, Forge migrates the variables to its file storage. The README does not list the exact labels in the provider login wizard.

[Full guide →](https://ailoot.ai/docs/en/integrations/forge/)[Application documentation ↗](https://github.com/tailcallhq/forgecode)

GC

### [GitHub Copilot CLI](https://ailoot.ai/docs/en/integrations/github-copilot-cli/)

Terminal agent

OpenAI ChatAnthropic Messages

Copilot in the terminal with custom models.

[Learn more →](https://ailoot.ai/docs/en/integrations/github-copilot-cli/)

#### Where to set it up

COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, and COPILOT\_MODEL environment variables (or the --model flag)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
export AILOOT_API_KEY="sk-..."
unset COPILOT_PROVIDER_TYPE
# OpenAI-compatible mode
export COPILOT_PROVIDER_BASE_URL=https://api.ailoot.ai/v1
export COPILOT_PROVIDER_API_KEY="$AILOOT_API_KEY"
export COPILOT_MODEL=gpt-6.1-sol
copilot

# Anthropic mode
export COPILOT_PROVIDER_TYPE=anthropic
export COPILOT_PROVIDER_BASE_URL=https://api.ailoot.ai
export COPILOT_PROVIDER_API_KEY="$AILOOT_API_KEY"
export COPILOT_MODEL=claude-sonnet-5-5
copilot
```

Example model: `gpt-6.1-sol`

#### Important

Types: openai (default, any OpenAI-compatible server), azure, anthropic. The model must support tool calling and streaming output. COPILOT\_PROVIDER\_WIRE\_API selects the protocol, but the page does not list its values. Limits can be set with COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS.

[Full guide →](https://ailoot.ai/docs/en/integrations/github-copilot-cli/)[Application documentation ↗](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)

Gp

### [gptme](https://ailoot.ai/docs/en/integrations/gptme/)

Terminal agent

OpenAI Chat

A personal terminal agent for code, files, and the browser.

[Learn more →](https://ailoot.ai/docs/en/integrations/gptme/)

#### Where to set it up

~/.config/gptme/config.toml → \[\[providers\]\]; select a model as \<provider\>/\<model\>

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.config/gptme/config.toml`

```toml
[[providers]]
name = "ailoot"
base_url = "https://api.ailoot.ai/v1"
api_key_env = "AILOOT_API_KEY"
default_model = "claude-sonnet-5-5"
```

```bash
export AILOOT_API_KEY="sk-..."
gptme 'hello' -m ailoot/claude-sonnet-5-5
```

Example model: `claude-sonnet-5-5`

#### Important

Any OpenAI-compatible server; the key is looked up in api\_key, then api\_key\_env, then \<NAME\>\_API\_KEY. List providers with gptme-util providers list.

[Full guide →](https://ailoot.ai/docs/en/integrations/gptme/)[Application documentation ↗](https://github.com/gptme/gptme/blob/master/docs/providers-custom.rst)

KC

### [Kilo Code CLI](https://ailoot.ai/docs/en/integrations/kilo-code-cli/)

Terminal agent

OpenAI ChatOpenAI ResponsesAnthropic Messages

Kilo Code’s command-line agent.

[Learn more →](https://ailoot.ai/docs/en/integrations/kilo-code-cli/)

#### Where to set it up

~/.config/kilo/kilo.jsonc (or ./kilo.jsonc; KILO\_CONFIG is also supported) → provider.\<id\>.options.baseURL; in the extension: Settings → Providers → Custom provider

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "$schema": "https://app.kilo.ai/config.json",
  "model": "openai-compatible/claude-sonnet-5-5",
  "provider": {
    "openai-compatible": {
      "options": {
        "apiKey": "{env:AILOOT_API_KEY}",
        "baseURL": "https://api.ailoot.ai/v1"
      },
      "models": {
        "claude-sonnet-5-5": {
          "name": "Claude Sonnet 5.5 (Ailoot)",
          "tool_call": true,
          "limit": {
            "context": 1000000,
            "output": 64000
          }
        }
      }
    }
  }
}
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

The Custom provider dialog lets you choose a protocol: OpenAI Compatible (Chat Completions), OpenAI Responses, or Anthropic Messages. {env:VAR} works only in the trusted global configuration (~/.config/kilo); the project-level kilo.json will not substitute a key from an environment variable.

[Full guide →](https://ailoot.ai/docs/en/integrations/kilo-code-cli/)[Application documentation ↗](https://kilo.ai/docs/code-with-ai/agents/custom-models)

LL

### [LLM](https://ailoot.ai/docs/en/integrations/llm-cli/)

Terminal agent

OpenAI ChatOpenAI Responses

A command-line utility for model requests.

[Learn more →](https://ailoot.ai/docs/en/integrations/llm-cli/)

#### Where to set it up

The extra-openai-models.yaml file in llm's configuration directory; set the key with llm keys set \<name\>

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`extra-openai-models.yaml`

```text
- model_id: ailoot-sonnet
  model_name: claude-sonnet-5-5
  api_base: "https://api.ailoot.ai/v1"
  api_key_name: ailoot
  supports_tools: true
  vision: true
- model_id: ailoot-gpt
  model_name: gpt-6.1-sol
  api_base: "https://api.ailoot.ai/v1"
  api_key_name: ailoot
  responses: true
```

```bash
llm keys set ailoot
llm -m ailoot-sonnet 'Hello'
```

Example model: `claude-sonnet-5-5`

#### Important

Chat Completions is the default; responses: true switches the model to /responses. When api\_base is set, the OpenAI key is not sent, so api\_key\_name is required. This is a CLI utility for making requests, not an agent.

[Full guide →](https://ailoot.ai/docs/en/integrations/llm-cli/)[Application documentation ↗](https://llm.datasette.io/en/stable/other-models.html)

MS

### [mini-SWE-agent](https://ailoot.ai/docs/en/integrations/mini-swe-agent/)

Terminal agent

OpenAI Chat

A minimal agent for repository tasks.

[Learn more →](https://ailoot.ai/docs/en/integrations/mini-swe-agent/)

#### Where to set it up

Agent YAML configuration → model section (model\_name, model\_kwargs); MSWEA\_MINI\_CONFIG\_PATH changes the default configuration path

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```yaml
# agent configuration snippet
model:
  model_name: "claude-sonnet-5-5"
  model_kwargs:
    custom_llm_provider: "openai"
    api_base: "https://api.ailoot.ai/v1"
  cost_tracking: "ignore_errors"
```

```bash
export AILOOT_API_KEY="sk-..."
export OPENAI_API_KEY="$AILOOT_API_KEY"
```

Example model: `claude-sonnet-5-5`

#### Important

Uses LiteLLM: model\_kwargs are passed directly to litellm.completion. Without a price registry, LiteLLM reports an unknown cost; disable tracking with cost\_tracking: "ignore\_errors" or MSWEA\_COST\_TRACKING=ignore\_errors. OPENAI\_API\_KEY is LiteLLM’s standard key variable, but the mini-SWE-agent page does not show it.

[Full guide →](https://ailoot.ai/docs/en/integrations/mini-swe-agent/)[Application documentation ↗](https://github.com/SWE-agent/mini-swe-agent/blob/main/docs/models/local_models.md)

OC

### [OpenHands CLI](https://ailoot.ai/docs/en/integrations/openhands-cli/)

Terminal agent

OpenAI Chat

An autonomous development agent for the command line.

[Learn more →](https://ailoot.ai/docs/en/integrations/openhands-cli/)

#### Where to set it up

Ctrl+P → Settings (provider and model), ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url), or LLM\_MODEL, LLM\_API\_KEY, and LLM\_BASE\_URL variables with --override-with-envs

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.openhands/agent_settings.json`

```json
{
  "llm": {
    "model": "openai/claude-sonnet-5-5",
    "api_key": "sk-...",
    "base_url": "https://api.ailoot.ai/v1"
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
# for a single run using environment variables:
export LLM_MODEL=openai/claude-sonnet-5-5
export LLM_API_KEY="$AILOOT_API_KEY"
export LLM_BASE_URL=https://api.ailoot.ai/v1
openhands --override-with-envs
```

Example model: `openai/claude-sonnet-5-5`

#### Important

OpenHands uses LiteLLM. For an OpenAI proxy, the documentation specifies a Custom Model such as openai/\<model\> and the proxy’s Base URL. Changes made through --override-with-envs are not saved. In the web interface: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

[Full guide →](https://ailoot.ai/docs/en/integrations/openhands-cli/)[Application documentation ↗](https://docs.openhands.dev/openhands/usage/cli/command-reference)

Pi

### [Pi](https://ailoot.ai/docs/en/integrations/pi/)

Terminal agent

OpenAI ChatAnthropic MessagesGemini

A minimal terminal coding agent.

[Learn more →](https://ailoot.ai/docs/en/integrations/pi/)

#### Where to set it up

~/.pi/agent/models.json, or the project’s .pi/models.json after trusting the project; select a model with /model

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "providers": {
    "ailoot": {
      "baseUrl": "https://api.ailoot.ai/v1",
      "api": "openai-completions",
      "apiKey": "$AILOOT_API_KEY",
      "models": [
        {
          "id": "claude-sonnet-5-5",
          "input": [
            "text",
            "image"
          ]
        },
        {
          "id": "deepseek-v4-pro"
        }
      ]
    }
  }
}
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

Pi documentation explicitly supports OpenAI-, Anthropic-, and Google-compatible endpoints through models.json; the example uses api: openai-completions. apiKey accepts $NAME/${NAME}, a literal value, or !command. The file is reread when /model opens.

[Full guide →](https://ailoot.ai/docs/en/integrations/pi/)[Application documentation ↗](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)

Pl

### [Plandex](https://ailoot.ai/docs/en/integrations/plandex/)

Terminal agent

OpenAI Chat

An agent for large tasks: plan, make changes in a sandbox, and apply them.

[Learn more →](https://ailoot.ai/docs/en/integrations/plandex/)

#### Where to set it up

plandex models custom, or \\models custom in the REPL, opens the JSON file for custom models and providers

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "providers": [
    {
      "name": "ailoot",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKeyEnvVar": "AILOOT_API_KEY"
    }
  ],
  "models": [
    {
      "modelId": "ailoot-claude-sonnet-5-5",
      "publisher": "anthropic",
      "description": "Claude Sonnet 5.5 via Ailoot",
      "defaultMaxConvoTokens": 75000,
      "maxTokens": 1000000,
      "maxOutputTokens": 64000,
      "reservedOutputTokens": 32000,
      "preferredOutputFormat": "xml",
      "providers": [
        {
          "provider": "custom",
          "customProvider": "ailoot",
          "modelName": "claude-sonnet-5-5"
        }
      ]
    }
  ]
}
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

Custom providers work only in self-hosted Plandex. In the cloud, BYO keys are limited to built-in providers. All custom providers must be OpenAI-compatible (Chat Completions). Then add the model to a custom model pack.

[Full guide →](https://ailoot.ai/docs/en/integrations/plandex/)[Application documentation ↗](https://github.com/plandex-ai/plandex/blob/main/docs/docs/models/custom-models.md)

TA

### [Trae Agent](https://ailoot.ai/docs/en/integrations/trae-agent/)

Terminal agent

OpenAI ChatAnthropic Messages

ByteDance’s research agent for development tasks.

[Learn more →](https://ailoot.ai/docs/en/integrations/trae-agent/)

#### Where to set it up

trae\_config.yaml → model\_providers.\<name\>.base\_url; alternatively, OPENAI\_BASE\_URL / ANTHROPIC\_BASE\_URL variables in .env

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`trae_config.yaml`

```yaml
agents:
  trae_agent:
    model: trae_agent_model

model_providers:
  openai:
    api_key: sk-...
    provider: openai
    base_url: https://api.ailoot.ai/v1

models:
  trae_agent_model:
    model_provider: openai
    model: gpt-6.1-sol
    max_tokens: 4096
    temperature: 0.5
```

Example model: `gpt-6.1-sol`

#### Important

Use spaces only in YAML, not tabs. For Anthropic format, use provider: anthropic and ANTHROPIC\_BASE\_URL. The README does not specify whether anthropic expects /v1; use https://api.ailoot.ai.

[Full guide →](https://ailoot.ai/docs/en/integrations/trae-agent/)[Application documentation ↗](https://github.com/bytedance/trae-agent#using-base-url)

Wa

### [Warp](https://ailoot.ai/docs/en/integrations/warp/)

Terminal agent

OpenAI Chat

A terminal with a built-in agent and custom model endpoint.

[Learn more →](https://ailoot.ai/docs/en/integrations/warp/)

#### Where to set it up

Settings → search for “inference endpoint” → Custom inference endpoint: base URL, key, model IDs; then select the model in the picker

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Settings → inference endpoint
  Endpoint URL: https://api.ailoot.ai/v1
  API key:      sk-...
  Models:       claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
Then select a model from the list, for example claude-sonnet-5-5 (not Auto).
```

Example model: `claude-sonnet-5-5`

#### Important

OpenAI Chat Completions only (POST /v1/chat/completions). Requests pass through Warp’s servers: the key is stored locally but sent to the Warp backend with every request. Auto mode and custom routers always use Warp credits; cloud agents do not use this endpoint. Available on Free and paid plans for individuals and teams of up to 10 people. Choose models whose current catalog entry lists OpenAI Chat. In the 2026-09-30 snapshot, gemini-3.6-flash has this format; check other Gemini models on their cards. This path does not use native Gemini format. A catalog method listing does not establish a live test of a specific client version.

[Full guide →](https://ailoot.ai/docs/en/integrations/warp/)[Application documentation ↗](https://docs.warp.dev/agents/inference/custom-inference-endpoint/)

## Editors and IDEs

Extensions and built-in assistants for code editors.

Cl

### [Cline](https://ailoot.ai/docs/en/integrations/cline/)

Editor extension

OpenAI ChatAnthropic Messages

An autonomous agent in VS Code and JetBrains: plans, edits, and commands.

[Learn more →](https://ailoot.ai/docs/en/integrations/cline/)

#### Where to set it up

Cline panel → gear icon (Settings) → API Provider = “OpenAI Compatible” → Base URL, API Key, Model ID fields. Another option: API Provider = “Anthropic” → check “Use custom base URL”.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
OpenAI Compatible (recommended):
  API Provider: OpenAI Compatible
  Base URL:     https://api.ailoot.ai/v1
  API Key:      sk-...
  Model ID:     claude-sonnet-5-5   (or gpt-6.1-sol, deepseek-v4-pro, qwen3.8-max)
  Model Configuration: Context Window and Max Output Tokens — match the model; Image Support — only for models that can process images.

Anthropic (Messages):
  API Provider:      Anthropic
  Anthropic API Key: sk-...
  [x] Use custom base URL → https://api.ailoot.ai
```

Example model: `claude-sonnet-5-5`

#### Important

OpenAI Compatible calls /v1/chat/completions, so the URL includes /v1. The Anthropic option calls /v1/messages and uses a URL without /v1, but its model list contains only Anthropic names; other Ailoot models are available through OpenAI Compatible. Agent mode requires a model that supports tool calling. Gemini 3.1 Pro models are not available through chat/completions (they support only the Gemini and Anthropic formats); use gemini-3.6-flash here.

[Full guide →](https://ailoot.ai/docs/en/integrations/cline/)[Application documentation ↗](https://docs.cline.bot/provider-config/openai-compatible)

RC

### [Roo Code](https://ailoot.ai/docs/en/integrations/roo-code/)

Editor extension

OpenAI ChatAnthropic Messages

A VS Code agent with modes for coding, architecture, and debugging.

[Learn more →](https://ailoot.ai/docs/en/integrations/roo-code/)

#### Where to set it up

Roo Code panel → gear icon → API Provider = “OpenAI Compatible” → Base URL, API Key, Model; optionally Model Configuration (Max Output Tokens, Context Window, Image Support, Computer Use, prices). The Anthropic provider has a “Use custom base URL” checkbox.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
API Provider: OpenAI Compatible
Base URL:     https://api.ailoot.ai/v1
API Key:      sk-...
Model:        gpt-6.1-sol   (or claude-sonnet-5-5, kimi-k3, glm-5.3)

Alternative via Anthropic:
API Provider: Anthropic, API key sk-..., [x] Use custom base URL → https://api.ailoot.ai
```

Example model: `gpt-6.1-sol`

#### Important

Roo Code calls tools only in OpenAI format, so the model must support tools in /v1/chat/completions. The Anthropic option calls /v1/messages and uses a URL without /v1.

[Full guide →](https://ailoot.ai/docs/en/integrations/roo-code/)[Application documentation ↗](https://roocodeinc.github.io/Roo-Code/providers/openai-compatible/)

KC

### [Kilo Code](https://ailoot.ai/docs/en/integrations/kilo-code/)

Editor extension

OpenAI Chat

A VS Code agent with modes and custom models.

[Learn more →](https://ailoot.ai/docs/en/integrations/kilo-code/)

#### Where to set it up

Settings (gear icon) → Providers tab → “Custom provider” at the bottom → Provider ID, Display name, Provider API = “OpenAI Compatible”, Base URL, API key, Models (the list is fetched from /v1/models). Settings are saved in kilo.json.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider ID:   ailoot
Display name:  Ailoot
Provider API:  OpenAI Compatible
Base URL:      https://api.ailoot.ai/v1
API key:       sk-...
Models:        select from the list, for example claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
```

Example model: `deepseek-v4-pro`

#### Important

Kilo requests {Base URL}/models and displays the model list automatically; our GET /v1/models returns the full catalog. You can also specify the full .../v1/chat/completions URL. Custom headers are supported.

[Full guide →](https://ailoot.ai/docs/en/integrations/kilo-code/)[Application documentation ↗](https://kilo.ai/docs/ai-providers/openai-compatible)

Co

### [Continue](https://ailoot.ai/docs/en/integrations/continue/)

Editor extension

OpenAI Chat

An assistant for VS Code and JetBrains: chat, edits, and agent mode.

[Learn more →](https://ailoot.ai/docs/en/integrations/continue/)

#### Where to set it up

The ~/.continue/config.yaml file (or Continue's configuration editor): an entry in models\[\] with provider: openai and apiBase.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
name: Ailoot
version: 0.0.1
schema: v1
models:
  - name: Ailoot Claude Sonnet 5.5
    provider: openai
    model: claude-sonnet-5-5
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...
  - name: Ailoot GPT-6.1 Sol
    provider: openai
    model: gpt-6.1-sol
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...
    # useResponsesApi: false   # only if you need to force requests to /chat/completions
```

Example model: `claude-sonnet-5-5`

#### Important

apiBase must end with /v1. For gpt-5/o-series names, Continue may automatically choose /v1/responses; our gpt-\* models support both /v1/responses and /v1/chat/completions, while useResponsesApi: false forces chat/completions. useLegacyCompletionsEndpoint is not needed.

[Full guide →](https://ailoot.ai/docs/en/integrations/continue/)[Application documentation ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Ze

### [Zed](https://ailoot.ai/docs/en/integrations/zed/)

Code editor

OpenAI ChatOpenAI ResponsesAnthropic Messages

A fast code editor with a built-in agent.

[Learn more →](https://ailoot.ai/docs/en/integrations/zed/)

#### Where to set it up

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider, or settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. Set the key in the settings window, where it is stored in the system keychain, or through \<PROVIDER\_ID\_UPPERCASE\>\_API\_KEY.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "language_models": {
    "openai_compatible": {
      "ailoot": {
        "api_url": "https://api.ailoot.ai/v1",
        "available_models": [
          {
            "name": "gpt-6.1-sol",
            "display_name": "GPT-6.1 Sol (Ailoot)",
            "max_tokens": 272000,
            "capabilities": {
              "tools": true,
              "images": false,
              "chat_completions": true
            }
          },
          {
            "name": "deepseek-v4-pro",
            "display_name": "DeepSeek V4 Pro (Ailoot)",
            "max_tokens": 128000
          }
        ]
      }
    },
    "anthropic_compatible": {
      "ailoot-claude": {
        "api_url": "https://api.ailoot.ai",
        "available_models": [
          {
            "name": "claude-sonnet-5-5",
            "display_name": "Claude Sonnet 5.5 (Ailoot)",
            "max_tokens": 200000,
            "capabilities": {
              "tools": true,
              "images": false,
              "prompt_caching": false
            }
          }
        ]
      }
    }
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
export AILOOT_CLAUDE_API_KEY="$AILOOT_API_KEY"
```

Example model: `gpt-6.1-sol`

#### Important

openai\_compatible uses a URL with /v1 and calls /v1/chat/completions; capabilities.chat\_completions = false switches the model to /v1/responses. anthropic\_compatible uses a URL without /v1 and calls /v1/messages; Zed sends x-api-key, which Ailoot accepts. images = false and parallel\_tool\_calls = false by default. Zed can send images, but enable images only for a specific model whose current catalog card declares image input in the selected API format. The GPT and Claude examples use images = false: the 2026-09-30 snapshot lists text only for them. For example, gemini-3.6-flash declares image input for OpenAI Chat in that snapshot; actual support depends on the model card and format. Reasoning models have a reasoning\_effort field. The example’s max\_tokens values represent context size; check exact limits in the model catalog.

[Full guide →](https://ailoot.ai/docs/en/integrations/zed/)[Application documentation ↗](https://zed.dev/docs/ai/use-api-access)

VC

### [VS Code + Copilot Chat](https://ailoot.ai/docs/en/integrations/vscode-copilot-byok/)

Editor extension

OpenAI ChatOpenAI ResponsesAnthropic Messages

A custom provider in Copilot Chat for VS Code.

[Learn more →](https://ailoot.ai/docs/en/integrations/vscode-copilot-byok/)

#### Where to set it up

Chat model picker → Manage Language Models (gear icon) → Add Models → Custom Endpoint → VS Code opens chatLanguageModels.json. The old github.copilot.chat.customOAIModels setting is deprecated.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
[
  {
    "name": "Ailoot",
    "vendor": "customendpoint",
    "apiKey": "${input:ailootApiKey}",
    "apiType": "chat-completions",
    "models": [
      {
        "id": "gpt-6.1-sol",
        "name": "GPT-6.1 Sol (Ailoot)",
        "url": "https://api.ailoot.ai/v1/chat/completions",
        "toolCalling": true,
        "vision": false,
        "maxInputTokens": 200000,
        "maxOutputTokens": 32000
      }
    ]
  },
  {
    "name": "Ailoot Claude",
    "vendor": "customendpoint",
    "apiKey": "${input:ailootApiKey}",
    "apiType": "messages",
    "models": [
      {
        "id": "claude-sonnet-5-5",
        "name": "Claude Sonnet 5.5 (Ailoot)",
        "url": "https://api.ailoot.ai/v1/messages",
        "toolCalling": true,
        "vision": false,
        "maxInputTokens": 200000,
        "maxOutputTokens": 32000
      }
    ]
  }
]
```

Example model: `gpt-6.1-sol`

#### Important

url is the FULL endpoint path. apiType values: chat-completions, responses (url .../v1/responses), messages (url .../v1/messages). BYOK works without a Copilot plan or GitHub sign-in, but only for chat/agent; inline suggestions stay on Copilot. Organization admins (Business/Enterprise) can disable the BYOK policy. The token limits above are examples; use catalog values. These examples use vision = false: the 2026-09-30 catalog snapshot lists text only for GPT/OpenAI Chat and Claude/Anthropic Messages. If your VS Code version offers vision, enable it only for a model whose current catalog card declares image input in the selected API format. A client field does not establish image support for the selected model.

[Full guide →](https://ailoot.ai/docs/en/integrations/vscode-copilot-byok/)[Application documentation ↗](https://code.visualstudio.com/docs/agent-customization/language-models)

JA

### [JetBrains AI Assistant](https://ailoot.ai/docs/en/integrations/jetbrains-ai-assistant/)

Code editor

OpenAI Chat

JetBrains’ built-in IDE assistant with your own key.

[Learn more →](https://ailoot.ai/docs/en/integrations/jetbrains-ai-assistant/)

#### Where to set it up

Settings | Tools | AI Assistant | Providers & API keys → Third-party AI providers → OpenAI-compatible → URL, API Key → Test Connection → Apply → AI Chat / Models Assignment

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider: OpenAI-compatible
URL: https://api.ailoot.ai/v1
API Key: sk-...
```

Example model: `claude-sonnet-5-5`

#### Important

Choose OpenAI-compatible and set URL to https://api.ailoot.ai/v1 with your API Key. Click Test Connection, then Apply, and select a model in AI Chat. Assign it in Models Assignment for IDE features. Enable Tool calling only when the chosen model supports tools; AI completion has separate settings.

[Full guide →](https://ailoot.ai/docs/en/integrations/jetbrains-ai-assistant/)[Application documentation ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

### [Xcode](https://ailoot.ai/docs/en/integrations/xcode/)

Code editor

OpenAI Chat

Coding Intelligence in Xcode with an external provider.

[Learn more →](https://ailoot.ai/docs/en/integrations/xcode/)

#### Where to set it up

Xcode → Settings → Intelligence → Chat → Add a Chat Provider → Internet Hosted → URL, API Key, API Key Header, description → Add.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Type:           Internet Hosted
URL:            https://api.ailoot.ai        (WITHOUT /v1: Xcode adds /v1/models and /v1/chat/completions itself)
API Key:        sk-...
API Key Header: x-api-key
Description:    Ailoot
→ then select models from the list (for example claude-sonnet-5-5, gpt-6.1-sol)
```

Example model: `claude-sonnet-5-5`

#### Important

Apple requires the provider to support Chat Completions and respond at {URL}/v1/models and {URL}/v1/chat/completions. Ailoot accepts x-api-key and Authorization: Bearer. Reports suggest Xcode adds the Bearer prefix itself when Authorization is selected. Xcode agents are configured separately and are outside this guide.

[Full guide →](https://ailoot.ai/docs/en/integrations/xcode/)[Application documentation ↗](https://developer.apple.com/documentation/xcode/setting-up-coding-intelligence)

AN

### [avante.nvim](https://ailoot.ai/docs/en/integrations/avante-nvim/)

Neovim plugin

OpenAI ChatAnthropic Messages

A Neovim plugin for chat and edits directly in the buffer.

[Learn more →](https://ailoot.ai/docs/en/integrations/avante-nvim/)

#### Where to set it up

opts for yetone/avante.nvim in lazy.nvim: opts.providers.\<name\> with \_\_inherited\_from = 'openai' (a custom OpenAI-compatible provider), or override providers.claude.endpoint; the key comes from the variable specified in api\_key\_name (AVANTE\_\* names are supported).

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```lua
opts = {
  provider = "ailoot",
  providers = {
    ailoot = {
      __inherited_from = "openai",
      endpoint = "https://api.ailoot.ai/v1",
      api_key_name = "AILOOT_API_KEY",
      model = "claude-sonnet-5-5",
    },
    claude = {
      endpoint = "https://api.ailoot.ai",   -- Anthropic Messages, without /v1
      model = "claude-sonnet-5-5",
    },
  },
}
-- in the terminal: export AILOOT_API_KEY=sk-...
-- the claude provider reads AVANTE_ANTHROPIC_API_KEY or ANTHROPIC_API_KEY
```

Example model: `claude-sonnet-5-5`

#### Important

In the plugin's wiki, the OpenAI-compatible URL ends with /v1 (the plugin appends /chat/completions). The built-in claude provider uses a URL such as https://api.anthropic.com, so use a URL without /v1 for Ailoot. Custom providers without \_\_inherited\_from require a full URL and their own response parsing functions.

[Full guide →](https://ailoot.ai/docs/en/integrations/avante-nvim/)[Application documentation ↗](https://github.com/avante-corp/avante.nvim/wiki/Custom-providers)

CN

### [codecompanion.nvim](https://ailoot.ai/docs/en/integrations/codecompanion-nvim/)

Neovim plugin

OpenAI ChatAnthropic Messages

Chat and inline edits in Neovim.

[Learn more →](https://ailoot.ai/docs/en/integrations/codecompanion-nvim/)

#### Where to set it up

require('codecompanion').setup({ adapters = { http = { ... } } }) using adapters.extend('openai\_compatible', ...) or extend('anthropic', ...); then interactions.chat/inline.adapter.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```lua
require("codecompanion").setup({
  adapters = {
    http = {
      ailoot = function()
        return require("codecompanion.adapters").extend("openai_compatible", {
          env = {
            url = "https://api.ailoot.ai",
            api_key = "AILOOT_API_KEY",        -- name of env var holding sk-...
            chat_url = "/v1/chat/completions",
          },
          schema = { model = { default = "gpt-6.1-sol" } },
        })
      end,
    },
  },
  interactions = {
    chat = { adapter = "ailoot" },
    inline = { adapter = "ailoot" },
  },
})
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `gpt-6.1-sol`

#### Important

openai\_compatible separates the host (env.url, without /v1) from the path (env.chat\_url). Values in env can be an environment variable name, cmd:..., file:..., or a Lua function. The anthropic adapter can similarly be extended with a custom url for /v1/messages.

[Full guide →](https://ailoot.ai/docs/en/integrations/codecompanion-nvim/)[Application documentation ↗](https://codecompanion.olimorris.dev/configuration/adapters-http)

Gp

### [gptel](https://ailoot.ai/docs/en/integrations/gptel/)

Emacs package

OpenAI ChatAnthropic MessagesGemini

A simple language-model client for Emacs.

[Learn more →](https://ailoot.ai/docs/en/integrations/gptel/)

#### Where to set it up

init.el: register a backend with gptel-make-openai (OpenAI Chat), gptel-make-anthropic (Messages), or gptel-make-gemini; each has :host, :endpoint, :key, :stream, :models. Then set gptel-backend and gptel-model.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```lisp
(setq gptel-model 'claude-sonnet-5-5
      gptel-backend
      (gptel-make-openai "Ailoot"
        :host "api.ailoot.ai"
        :endpoint "/v1/chat/completions"
        :stream t
        :key (getenv "AILOOT_API_KEY")               ; or (gptel-api-key-from-environment "AILOOT_API_KEY")
        :models '(claude-sonnet-5-5 gpt-6.1-sol deepseek-v4-pro qwen3.8-max)))

;; Anthropic Messages variant
(gptel-make-anthropic "Ailoot-Claude"
  :host "api.ailoot.ai"          ; default path /v1/messages
  :stream t
  :key (getenv "AILOOT_API_KEY")
  :models '(claude-sonnet-5-5 claude-opus-5-5))
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5`

#### Important

:host is only the hostname (without https:// or a path); set the path in :endpoint. gptel-make-anthropic sends the x-api-key and anthropic-version headers, which Ailoot accepts.

[Full guide →](https://ailoot.ai/docs/en/integrations/gptel/)[Application documentation ↗](https://github.com/karthink/gptel)

TI

### [Theia IDE](https://ailoot.ai/docs/en/integrations/theia/)

Code editor

OpenAI Chat

An open-source IDE with Theia AI.

[Learn more →](https://ailoot.ai/docs/en/integrations/theia/)

#### Where to set it up

Preferences → AI-features → OpenAiCustom, or the ai-features.openAiCustom.customOpenAiModels key in settings.json; open AI Configuration with Alt+A.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "ai-features.openAiCustom.customOpenAiModels": [
    {
      "model": "claude-sonnet-5-5",
      "url": "https://api.ailoot.ai/v1",
      "id": "ailoot-claude-sonnet-5-5",
      "apiKey": "sk-...",
      "developerMessageSettings": "system"
    }
  ]
}
```

Example model: `claude-sonnet-5-5`

#### Important

url is the base URL ending in /v1. For models not from OpenAI, developerMessageSettings: "system" is the safe choice.

[Full guide →](https://ailoot.ai/docs/en/integrations/theia/)[Application documentation ↗](https://theia-ide.org/docs/user_ai/)

TI

### [Trae IDE](https://ailoot.ai/docs/en/integrations/trae/)

Code editor

OpenAI ChatAnthropic Messages

Trae code editor with custom models.

[Learn more →](https://ailoot.ai/docs/en/integrations/trae/)

#### Where to set it up

Settings → Models → Add Model → Custom Model → API Format, Request URL (Full URL toggle), Model ID, Display Name, API Key; optionally Advanced Settings.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
OpenAI format:
  API Format:  OpenAI Chat Completions
  Full URL:    OFF
  Request URL: https://api.ailoot.ai/v1
  Model ID:    gpt-6.1-sol
  API Key:     sk-...

Anthropic format:
  API Format:  Anthropic Messages
  Full URL:    OFF
  Request URL: https://api.ailoot.ai
  Model ID:    claude-sonnet-5-5
  API Key:     sk-...
```

Example model: `gpt-6.1-sol`

#### Important

With Full URL disabled, Trae appends the selected format’s path: include /v1 for OpenAI and omit it for Anthropic. With Full URL enabled, enter https://api.ailoot.ai/v1/chat/completions or https://api.ailoot.ai/v1/messages. Model Series adapts hints to the model family.

[Full guide →](https://ailoot.ai/docs/en/integrations/trae/)[Application documentation ↗](https://docs.trae.ai/ide/models)

## Chat applications

Chat apps for desktop, mobile, and the browser, plus note-taking apps and launchers.

OW

### [Open WebUI](https://ailoot.ai/docs/en/integrations/open-webui/)

Self-hosted web chat

OpenAI Chat

A popular self-hosted web chat.

[Learn more →](https://ailoot.ai/docs/en/integrations/open-webui/)

#### Where to set it up

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection, or OPENAI\_API\_BASE\_URL / OPENAI\_API\_KEY environment variables when starting the container

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
UI: URL = https://api.ailoot.ai/v1
API Key = sk-...
Model IDs: leave blank (loaded from /v1/models) or manually add claude-sonnet-5-5, gpt-6.1-sol

Docker env:
OPENAI_API_BASE_URL=https://api.ailoot.ai/v1
OPENAI_API_KEY=sk-...
```

Example model: `claude-sonnet-5-5`

#### Important

Uses OpenAI Chat Completions. The URL must include /v1 and have no trailing slash. The model list comes from /v1/models. For a large catalog (252 models), limiting Model IDs and enabling model-list caching is more convenient: Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True. RAG embeddings use a separate RAG\_OPENAI\_API\_BASE\_URL.

[Full guide →](https://ailoot.ai/docs/en/integrations/open-webui/)[Application documentation ↗](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/)

Li

### [LibreChat](https://ailoot.ai/docs/en/integrations/librechat/)

Self-hosted web chat

OpenAI ChatAnthropic Messages

A self-hosted web chat with agents and multiple providers.

[Learn more →](https://ailoot.ai/docs/en/integrations/librechat/)

#### Where to set it up

librechat.yaml file → endpoints.custom (key in .env via ${VAR}); for the Anthropic format, use provider: 'anthropic'

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```yaml
endpoints:
  custom:
    - name: 'Ailoot'
      apiKey: '${AILOOT_API_KEY}'
      baseURL: 'https://api.ailoot.ai/v1'
      models:
        default: ['gpt-6.1-sol', 'claude-sonnet-5-5', 'deepseek-v4-pro']
        fetch: true
      titleConvo: true
      titleModel: 'gpt-6.1-sol'
      modelDisplayLabel: 'Ailoot'
    - name: 'Ailoot Claude'
      provider: 'anthropic'
      apiKey: '${AILOOT_API_KEY}'
      baseURL: 'https://api.ailoot.ai'
      models:
        default: ['claude-sonnet-5-5']
        fetch: false
# .env: AILOOT_API_KEY=sk-...
```

Example model: `gpt-6.1-sol`

#### Important

A standard custom endpoint uses OpenAI Chat Completions (baseURL with /v1). provider: 'anthropic' enables the native /v1/messages client. The documentation's Anthropic example specifies baseURL without /v1 (https://api.anthropic.com), so use https://api.ailoot.ai for Ailoot. fetch: true retrieves the list from /v1/models.

[Full guide →](https://ailoot.ai/docs/en/integrations/librechat/)[Application documentation ↗](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

CS

### [Cherry Studio](https://ailoot.ai/docs/en/integrations/cherry-studio/)

Desktop application

OpenAI ChatOpenAI ResponsesAnthropic Messages

A desktop client with assistants and a knowledge base.

[Learn more →](https://ailoot.ai/docs/en/integrations/cherry-studio/)

#### Where to set it up

Settings (gear icon) \> Model Provider \> + Add Provider \> protocol type: OpenAI / OpenAI Responses / Anthropic / Gemini

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider Name: Ailoot
Type: OpenAI (or OpenAI Responses / Anthropic)
API Key: sk-...
Base URL: https://api.ailoot.ai
→ check the preview of the final URL below the field: it should be https://api.ailoot.ai/v1/chat/completions (for Anthropic: https://api.ailoot.ai/v1/messages)
Models: + claude-sonnet-5-5, gpt-6.1-sol
Then click Model Check
```

Example model: `claude-sonnet-5-5`

#### Important

The documentation confirms support for the OpenAI, Anthropic, OpenAI Responses, and Gemini protocols, and a preview of the final path below the field, but it does not describe the rules for appending /v1 — use the preview as your guide. All three of our formats (Chat Completions, Responses, Messages) are compatible.

[Full guide →](https://ailoot.ai/docs/en/integrations/cherry-studio/)[Application documentation ↗](https://cherryai.com/docs/en/pre-basic/providers/zi-ding-yi-fu-wu-shang/)

Ch

### [Chatbox](https://ailoot.ai/docs/en/integrations/chatbox/)

Desktop and mobile

OpenAI Chat

Chat for desktop and mobile.

[Learn more →](https://ailoot.ai/docs/en/integrations/chatbox/)

#### Where to set it up

Settings (sidebar button) \> Model Provider \> Add (at the bottom) \> type: OpenAI API Compatible

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Name: Ailoot
API Mode: OpenAI API Compatible
API Key: sk-...
API Host: https://api.ailoot.ai
API Path: (blank, defaults to /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision is disabled in these examples; tool_use depends on the capabilities of the selected model)
```

Example model: `gpt-6.1-sol`

#### Important

The documentation lists API Host without /v1 (example: https://api.openai.com), with /v1/chat/completions as the default path. There is also a Google Gemini compatible type, but it has not been tested with our /v1beta. JSON configuration import (type: 'openai', apiHost, apiPath) is available from 1.15.1 via chatbox://provider/import?config=\<base64\>. Vision is disabled for the GPT and Claude examples shown: the 2026-09-30 catalog snapshot lists only text for the OpenAI Chat format. If your Chatbox version offers vision, enable it only for a model whose current catalog card lists image input in the selected API format; a client's ability to attach an image does not prove that the model supports it.

[Full guide →](https://ailoot.ai/docs/en/integrations/chatbox/)[Application documentation ↗](https://docs.chatboxai.app/en/guides/providers)

Lo

### [LobeChat](https://ailoot.ai/docs/en/integrations/lobechat/)

Self-hosted web chat

OpenAI ChatAnthropic Messages

A modern chat with plugins and a knowledge base.

[Learn more →](https://ailoot.ai/docs/en/integrations/lobechat/)

#### Where to set it up

Self-hosting: OPENAI\_PROXY\_URL / OPENAI\_API\_KEY / OPENAI\_MODEL\_LIST, ANTHROPIC\_PROXY\_URL, and GOOGLE\_PROXY\_URL environment variables

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
OPENAI_API_KEY=sk-...
OPENAI_PROXY_URL=https://api.ailoot.ai/v1
OPENAI_MODEL_LIST=-all,+gpt-6.1-sol,+claude-sonnet-5-5,+deepseek-v4-pro

# Anthropic format (optional)
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_PROXY_URL=https://api.ailoot.ai
```

Example model: `claude-sonnet-5-5`

#### Important

OPENAI\_PROXY\_URL defaults to https://api.openai.com/v1, so include /v1. ANTHROPIC\_PROXY\_URL defaults to https://api.anthropic.com, without /v1. GOOGLE\_PROXY\_URL can in principle connect Gemini format through https://api.ailoot.ai, but we have not tested this option. Use server mode: requests sent directly from the browser may currently be rejected by Ailoot’s CORS rules.

[Full guide →](https://ailoot.ai/docs/en/integrations/lobechat/)[Application documentation ↗](https://lobehub.com/docs/self-hosting/environment-variables/model-provider)

Ja

### [Jan](https://ailoot.ai/docs/en/integrations/jan/)

Desktop application

OpenAI ChatAnthropic Messages

An open-source desktop chat for local and cloud models.

[Learn more →](https://ailoot.ai/docs/en/integrations/jan/)

#### Where to set it up

Settings \> Model Providers \> Add Provider → choose the OpenAI-compatible or Anthropic-compatible format

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
OpenAI-compatible:
  Provider name: Ailoot
  Base URL: https://api.ailoot.ai/v1
  API key: sk-...
Anthropic-compatible:
  Provider name: Ailoot Claude
  Base URL: https://api.ailoot.ai
  API key: sk-...
Models: loaded from {base_url}/models or + manually: claude-sonnet-5-5
```

Example model: `claude-sonnet-5-5`

#### Important

Docs: for OpenAI-compatible providers, Base URL must include /v1 (otherwise you get 404); a trailing slash is removed. The Anthropic-mode example for LiteLLM omits /v1. Model capabilities (tools, vision) must be configured manually for custom providers. Backup keys are supported (retries only on 401/403/429).

[Full guide →](https://ailoot.ai/docs/en/integrations/jan/)[Application documentation ↗](https://www.jan.ai/docs/desktop/remote-models/custom-endpoint)

Si

### [SillyTavern](https://ailoot.ai/docs/en/integrations/sillytavern/)

Roleplay chat

OpenAI Chat

An interface for roleplay chats and characters.

[Learn more →](https://ailoot.ai/docs/en/integrations/sillytavern/)

#### Where to set it up

API Connections \> API: Chat Completion \> Chat Completion Source: Custom (OpenAI-compatible)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Custom Endpoint (Base URL): https://api.ailoot.ai/v1
Custom API Key: sk-...
Model: select from the list (/v1/models) or enter claude-sonnet-5-5
```

Example model: `claude-sonnet-5-5`

#### Important

The documentation says to add /v1 when troubleshooting a connection and NOT to add /chat/completions. Models are fetched if the server provides /v1/models, which Ailoot does.

[Full guide →](https://ailoot.ai/docs/en/integrations/sillytavern/)[Application documentation ↗](https://docs.sillytavern.app/usage/api-connections/openai/)

An

### [AnythingLLM](https://ailoot.ai/docs/en/integrations/anythingllm/)

Chat with documents

OpenAI Chat

Chat with your documents on a computer or server.

[Learn more →](https://ailoot.ai/docs/en/integrations/anythingllm/)

#### Where to set it up

Settings \> AI Providers \> LLM \> Generic OpenAI (Docker: env LLM\_PROVIDER='generic-openai')

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
UI: Base URL = https://api.ailoot.ai/v1
API Key = sk-...
Chat Model Name = deepseek-v4-pro
Token context window = according to the model

Docker .env:
LLM_PROVIDER='generic-openai'
GENERIC_OPEN_AI_BASE_PATH='https://api.ailoot.ai/v1'
GENERIC_OPEN_AI_MODEL_PREF='deepseek-v4-pro'
GENERIC_OPEN_AI_MODEL_TOKEN_LIMIT=128000
GENERIC_OPEN_AI_API_KEY='sk-...'
```

Example model: `deepseek-v4-pro`

#### Important

The documentation labels this provider “for developers”. If needed, use GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Embeddings have a separate generic-openai embedder (EMBEDDING\_BASE\_PATH + GENERIC\_OPEN\_AI\_EMBEDDING\_API\_KEY) — the nemotron-3-embed model through /v1/embeddings.

[Full guide →](https://ailoot.ai/docs/en/integrations/anythingllm/)[Application documentation ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

### [big-AGI](https://ailoot.ai/docs/en/integrations/big-agi/)

Self-hosted web chat

OpenAI ChatAnthropic Messages

An advanced web interface for working with multiple models.

[Learn more →](https://ailoot.ai/docs/en/integrations/big-agi/)

#### Where to set it up

Environment variables at deployment: OPENAI\_API\_KEY / OPENAI\_API\_HOST, ANTHROPIC\_API\_KEY / ANTHROPIC\_API\_HOST; in the UI — Models \> Add OpenAI-compatible

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
OPENAI_API_KEY=sk-...
OPENAI_API_HOST=https://api.ailoot.ai
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_API_HOST=https://api.ailoot.ai
```

Example model: `claude-sonnet-5-5`

#### Important

The documentation describes these variables as overrides for the OpenAI and Anthropic backend host (for proxies and custom endpoints). It says “host”, so we use a URL without /v1, but the documentation does not specify the exact path format — check it on the first request.

[Full guide →](https://ailoot.ai/docs/en/integrations/big-agi/)[Application documentation ↗](https://github.com/enricoros/big-AGI/blob/main/docs/environment-variables.md)

Bo

### [BoltAI](https://ailoot.ai/docs/en/integrations/boltai/)

Mac application

OpenAI Chat

A native AI client for macOS.

[Learn more →](https://ailoot.ai/docs/en/integrations/boltai/)

#### Where to set it up

Settings \> Models \> (+) \> OpenAI-compatible Server

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Friendly name: Ailoot
API Endpoint URL: https://api.ailoot.ai/v1/chat/completions
API Key: sk-...
Model ID: gpt-6.1-sol
Context length: according to the model
Streaming: enable
```

Example model: `gpt-6.1-sol`

#### Important

A full chat completions URL is required. To use it with AI Command, make this service the default. These instructions follow the BoltAI help pages; screens may differ in BoltAI 2.

[Full guide →](https://ailoot.ai/docs/en/integrations/boltai/)[Application documentation ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

### [Hugging Face Chat UI](https://ailoot.ai/docs/en/integrations/hugging-face-chat-ui/)

Self-hosted web chat

OpenAI Chat

Hugging Face’s open-source self-hosted web chat.

[Learn more →](https://ailoot.ai/docs/en/integrations/hugging-face-chat-ui/)

#### Where to set it up

The .env.local file (OPENAI\_BASE\_URL, OPENAI\_API\_KEY)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
OPENAI_BASE_URL=https://api.ailoot.ai/v1
OPENAI_API_KEY=sk-...
```

Example model: `deepseek-v4-pro`

#### Important

Chat UI works only with OpenAI-compatible APIs through OPENAI\_BASE\_URL and retrieves its model list from /models.

[Full guide →](https://ailoot.ai/docs/en/integrations/hugging-face-chat-ui/)[Application documentation ↗](https://github.com/huggingface/chat-ui)

MS

### [Msty Studio](https://ailoot.ai/docs/en/integrations/msty-studio/)

Desktop application

OpenAI Chat

A desktop chat with local and cloud models.

[Learn more →](https://ailoot.ai/docs/en/integrations/msty-studio/)

#### Where to set it up

Model Hub \> Model Providers \> Add Provider \> OpenAI-compatible

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider: OpenAI Compatible
Name: Ailoot
API Endpoint: https://api.ailoot.ai/v1
API Key: sk-...
Models: gpt-6.1-sol, claude-sonnet-5-5
```

Example model: `gpt-6.1-sol`

#### Important

The documentation confirms a custom OpenAI-compatible provider but does not specify the URL format. /v1 is the standard OpenAI API root; if you receive 404, check the URL without /v1. A custom Anthropic-compatible endpoint is not described.

[Full guide →](https://ailoot.ai/docs/en/integrations/msty-studio/)[Application documentation ↗](https://docs.msty.ai/studio/managing-models/online-providers)

Ne

### [NextChat](https://ailoot.ai/docs/en/integrations/nextchat/)

Self-hosted web chat

OpenAI Chat

A lightweight web chat that is quick to deploy.

[Learn more →](https://ailoot.ai/docs/en/integrations/nextchat/)

#### Where to set it up

Vercel / Docker: BASE\_URL, OPENAI\_API\_KEY, CUSTOM\_MODELS, DEFAULT\_MODEL

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
OPENAI_API_KEY=sk-...
BASE_URL=https://api.ailoot.ai
CUSTOM_MODELS=-all,+gpt-6.1-sol,+claude-sonnet-5-5,+deepseek-v4-pro
DEFAULT_MODEL=gpt-6.1-sol
```

Example model: `gpt-6.1-sol`

#### Important

Use OpenAI Chat through the NextChat server for this setup. When deploying on Vercel or Docker, set BASE\_URL=https://api.ailoot.ai without /v1, OPENAI\_API\_KEY, CUSTOM\_MODELS and DEFAULT\_MODEL. Redeploy the server after changing these variables.

[Full guide →](https://ailoot.ai/docs/en/integrations/nextchat/)[Application documentation ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

### [Obsidian Copilot](https://ailoot.ai/docs/en/integrations/obsidian-copilot/)

Obsidian plugin

OpenAI Chat

Chat with your Obsidian notes.

[Learn more →](https://ailoot.ai/docs/en/integrations/obsidian-copilot/)

#### Where to set it up

Settings \> Copilot \> BYOK \> Add a provider \> Add a custom provider

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Base URL: https://api.ailoot.ai/v1
API key: sk-...
Model ID: claude-sonnet-5-5 (or select from the /v1/models list)
Then Test; enable the model in Basic > Agents > Quick Chat
```

Example model: `claude-sonnet-5-5`

#### Important

The model list comes from /v1/models, and you can enter a model manually. If Test passes but Quick Chat does not send messages, turn on Enable CORS for the provider; the response will arrive in full without streaming. Keys are stored in Obsidian Keychain.

[Full guide →](https://ailoot.ai/docs/en/integrations/obsidian-copilot/)[Application documentation ↗](https://github.com/logancyang/obsidian-copilot/blob/master/docs/llm-providers.md)

PA

### [Page Assist](https://ailoot.ai/docs/en/integrations/page-assist/)

Browser extension

OpenAI Chat

A browser extension for chatting with the open page.

[Learn more →](https://ailoot.ai/docs/en/integrations/page-assist/)

#### Where to set it up

Page Assist icon \> Settings \> OpenAI Compatible API \> Add Provider \> Custom

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider: Custom
Name: Ailoot
Base URL: https://api.ailoot.ai/v1
API Key: sk-...
Then manually add the models: gpt-6.1-sol, claude-sonnet-5-5
```

Example model: `gpt-6.1-sol`

#### Important

The documentation confirms Custom with an API URL and key but does not specify the URL format. /v1 is the standard OpenAI API root. Automatic model discovery is guaranteed only for Ollama, LM Studio, and Llamafile; other providers require models to be added manually.

[Full guide →](https://ailoot.ai/docs/en/integrations/page-assist/)[Application documentation ↗](https://docs.pageassist.xyz/providers/openai)

RA

### [Raycast AI](https://ailoot.ai/docs/en/integrations/raycast-ai/)

Launcher

OpenAI Chat

AI in the Raycast launcher: quick commands and chat.

[Learn more →](https://ailoot.ai/docs/en/integrations/raycast-ai/)

#### Where to set it up

Settings \> AI \> Models & Providers \> Custom Providers \> Reveal Providers Config → ~/.config/raycast/ai/providers.yaml

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```yaml
providers:
  - id: ailoot
    name: Ailoot
    base_url: https://api.ailoot.ai/v1
    api_keys:
      ailoot: sk-...
    models:
      - id: claude-sonnet-5-5
        name: Claude Sonnet 5.5
        provider: ailoot
        context: 200000
        abilities:
          temperature:
            supported: true
          vision:
            supported: false
          system_message:
            supported: true
          tools:
            supported: true
      - id: gpt-6.1-sol
        name: GPT-6.1 Sol
        provider: ailoot
```

Example model: `claude-sonnet-5-5`

#### Important

base\_url is an OpenAI-compatible endpoint without the /chat/completions suffix. Raycast rereads the file without restarting. If abilities is not set, tools and vision are treated as unsupported. Models appear in Quick AI, AI Chat, and AI Commands. This example uses vision.supported = false: the 2026-09-30 catalog snapshot lists text only for Claude/OpenAI Chat. If your Raycast version supports this setting, enable vision only for a model whose current catalog card declares image input in OpenAI Chat format; the client flag alone does not prove API image support.

[Full guide →](https://ailoot.ai/docs/en/integrations/raycast-ai/)[Application documentation ↗](https://manual.raycast.com/ai/custom-providers)

Ty

### [TypingMind](https://ailoot.ai/docs/en/integrations/typingmind/)

Web application

OpenAI Chat

A convenient chat interface for browser and desktop.

[Learn more →](https://ailoot.ai/docs/en/integrations/typingmind/)

#### Where to set it up

Models in the left sidebar \> + Add Custom Model

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Name: Claude Sonnet 5.5 (Ailoot)
API Type: OpenAI Chat Completions
Endpoint: https://api.ailoot.ai/v1/chat/completions
Model ID: claude-sonnet-5-5
Custom Headers: Authorization = Bearer sk-...
Context Length: according to the model
Test → Save
```

Example model: `claude-sonnet-5-5`

#### Important

Enter Endpoint as the full path. The key is sent through a custom Authorization: Bearer sk-... header, which Ailoot accepts. TypingMind’s web version calls the API directly from the browser, and CORS may currently block these requests; the desktop version is more reliable. TypingMind’s Gemini type sends the key in apiKey, which Ailoot does not accept. Use OpenAI Chat Completions instead.

[Full guide →](https://ailoot.ai/docs/en/integrations/typingmind/)[Application documentation ↗](https://docs.typingmind.com/manage-and-connect-ai-models/ollama)

## SDKs and frameworks

Libraries for your own apps, agents, and RAG.

OS

### [OpenAI SDK (Python)](https://ailoot.ai/docs/en/integrations/openai-python-sdk/)

SDK

OpenAI ChatOpenAI Responses

The official OpenAI library for Python.

[Learn more →](https://ailoot.ai/docs/en/integrations/openai-python-sdk/)

#### Where to set it up

OpenAI(base\_url=..., api\_key=...) constructor parameters, or OPENAI\_BASE\_URL and OPENAI\_API\_KEY environment variables

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
export AILOOT_API_KEY="sk-..."
# environment variables
export OPENAI_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_API_KEY="$AILOOT_API_KEY"

# or in code
```

`ailoot-openai-python-sdk.py`

```python
import os
from openai import OpenAI
client = OpenAI(max_retries=0, base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
r = client.chat.completions.create(model="gpt-6.1-sol", messages=[{"role":"user","content":"Hello"}])
print(r.choices[0].message.content)
# Responses API: client.responses.create(model="gpt-6.1-sol", input="Hello")
# Embeddings: client.embeddings.create(model="nemotron-3-embed", input=["text"])
```

```bash
python3 ailoot-openai-python-sdk.py
```

Example model: `gpt-6.1-sol, claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-max (chat); nemotron-3-embed (embeddings)`

#### Important

Include /v1 in the URL: the SDK appends /chat/completions, /responses, /embeddings, /images/\*, and /audio/\*. Chat Completions and Responses work; Responses requires a model whose catalog entry lists that format. Streaming and tools use the standard formats. Ailoot errors are JSON with a Request ID and are caught as openai.APIStatusError.

[Full guide →](https://ailoot.ai/docs/en/integrations/openai-python-sdk/)[Application documentation ↗](https://github.com/openai/openai-python)

OS

### [OpenAI SDK (Node.js)](https://ailoot.ai/docs/en/integrations/openai-node-js-sdk/)

SDK

OpenAI ChatOpenAI Responses

The official OpenAI library for JavaScript and TypeScript.

[Learn more →](https://ailoot.ai/docs/en/integrations/openai-node-js-sdk/)

#### Where to set it up

Constructor option new OpenAI({ baseURL, apiKey }); the SDK reads OPENAI\_BASE\_URL by default

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```js
import OpenAI from "openai";
const client = new OpenAI({maxRetries: 0,
  baseURL: "https://api.ailoot.ai/v1",
  apiKey: process.env.AILOOT_API_KEY // sk-...
});
const r = await client.chat.completions.create({
  model: "claude-sonnet-5-5",
  messages: [{ role: "user", content: "Hello" }]
});
console.log(r.choices[0].message.content);
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `claude-sonnet-5-5, gpt-6.1-sol, grok-4.7`

#### Important

The README shows baseURL. Reading OPENAI\_BASE\_URL is visible in the client source, src/client.ts; its default is https://api.openai.com/v1. Include /v1 in the Ailoot URL. Both chat.completions and responses are available.

[Full guide →](https://ailoot.ai/docs/en/integrations/openai-node-js-sdk/)[Application documentation ↗](https://github.com/openai/openai-node)

AS

### [Anthropic SDK (Python)](https://ailoot.ai/docs/en/integrations/anthropic-python-sdk/)

SDK

Anthropic Messages

The official Anthropic library for Python.

[Learn more →](https://ailoot.ai/docs/en/integrations/anthropic-python-sdk/)

#### Where to set it up

The Anthropic(base\_url=...) parameter or ANTHROPIC\_BASE\_URL environment variable; key: api\_key or ANTHROPIC\_API\_KEY

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
export AILOOT_API_KEY="sk-..."
export ANTHROPIC_BASE_URL="https://api.ailoot.ai"
export ANTHROPIC_API_KEY="$AILOOT_API_KEY"
```

`ailoot-anthropic-python-sdk.py`

```python
import os
from anthropic import Anthropic
client = Anthropic(max_retries=0, base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"])
msg = client.messages.create(
    model="claude-sonnet-5-5", max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}])
print(msg.content[0].text)
```

```bash
python3 ailoot-anthropic-python-sdk.py
```

Example model: `claude-sonnet-5-5, claude-opus-5-5; also via /v1/messages gpt-6.1-sol, deepseek-v4-pro, gemini-3.6-flash`

#### Important

Use a URL WITHOUT /v1: the SDK adds /v1/messages itself. The gateway accepts the key in x-api-key (as sent by the SDK) and Authorization: Bearer. Streaming, tools, and /v1/messages/count\_tokens work. Batch processing (Batches) and the Files API are not listed as supported in the Ailoot catalog.

[Full guide →](https://ailoot.ai/docs/en/integrations/anthropic-python-sdk/)[Application documentation ↗](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python)

VA

### [Vercel AI SDK](https://ailoot.ai/docs/en/integrations/vercel-ai-sdk/)

SDK

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

A TypeScript framework for AI applications with any provider.

[Learn more →](https://ailoot.ai/docs/en/integrations/vercel-ai-sdk/)

#### Where to set it up

Providers: createOpenAICompatible({ name, baseURL, apiKey }) from @ai-sdk/openai-compatible; createAnthropic({ baseURL, apiKey }) from @ai-sdk/anthropic; createGoogleGenerativeAI({ baseURL, apiKey }) from @ai-sdk/google; createOpenAI({ baseURL }) or OPENAI\_BASE\_URL

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```js
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { createAnthropic } from "@ai-sdk/anthropic";
import { createGoogleGenerativeAI } from "@ai-sdk/google";
import { generateText } from "ai";

const ailoot = createOpenAICompatible({ name: "ailoot", baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY });
const claude = createAnthropic({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY });
const gemini = createGoogleGenerativeAI({ baseURL: "https://api.ailoot.ai/v1beta", apiKey: process.env.AILOOT_API_KEY });

const { text } = await generateText({ model: ailoot("deepseek-v4-pro"), prompt: "Hello" });
// claude("claude-sonnet-5-5"), gemini("gemini-3.6-flash")
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `deepseek-v4-pro (OpenAI-compatible), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Important

Providers use different URLs: OpenAI-compatible and Anthropic use /v1 (Anthropic defaults to https://api.anthropic.com/v1); Google uses /v1beta (default https://generativelanguage.googleapis.com/v1beta). The @ai-sdk/openai provider defaults to the Responses API. For models without responses, use openai.chat("id") or createOpenAICompatible.

[Full guide →](https://ailoot.ai/docs/en/integrations/vercel-ai-sdk/)[Application documentation ↗](https://ai-sdk.dev/providers/openai-compatible-providers)

La

### [LangChain](https://ailoot.ai/docs/en/integrations/langchain/)

Framework

OpenAI ChatOpenAI ResponsesAnthropic Messages

A framework for chains, agents, and RAG.

[Learn more →](https://ailoot.ai/docs/en/integrations/langchain/)

#### Where to set it up

ChatOpenAI(base\_url=...) or the OPENAI\_API\_BASE / OPENAI\_BASE\_URL environment variables; ChatAnthropic(base\_url=...) or ANTHROPIC\_API\_URL / ANTHROPIC\_BASE\_URL

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```python
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-6.1-sol", base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
print(llm.invoke("Hello").content)

from langchain_anthropic import ChatAnthropic
claude = ChatAnthropic(model="claude-sonnet-5-5", base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"])
```

Example model: `gpt-6.1-sol, qwen3.8-max (ChatOpenAI); claude-sonnet-5-5 (ChatAnthropic)`

#### Important

ChatOpenAI: use a URL with /v1. According to the documentation, ChatOpenAI supports only the official OpenAI specification: nonstandard fields such as reasoning\_content from third-party models are not retained. For Claude, prefer ChatAnthropic: use a URL without /v1, as the SDK adds /v1/messages automatically. ChatAnthropic's base\_url parameter and ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL environment variables are documented in the class documentation in the source code (langchain\_anthropic/chat\_models.py), but not on the integration page. The use\_responses\_api flag enables Responses mode in ChatOpenAI.

[Full guide →](https://ailoot.ai/docs/en/integrations/langchain/)[Application documentation ↗](https://docs.langchain.com/oss/python/integrations/chat/openai)

Cr

### [CrewAI](https://ailoot.ai/docs/en/integrations/crewai/)

Agent framework

OpenAI ChatAnthropic Messages

Agent teams with roles and tasks.

[Learn more →](https://ailoot.ai/docs/en/integrations/crewai/)

#### Where to set it up

crewai.LLM(model=..., base\_url=..., api\_key=...); OPENAI\_API\_KEY and OPENAI\_BASE\_URL environment variables; for Claude, the native anthropic/ provider with base\_url

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/messages, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```python
import os
from crewai import LLM
# OpenAI-compatible format
llm = LLM(model="openai/gpt-6.1-sol", base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
# Anthropic Messages
claude = LLM(model="anthropic/claude-sonnet-5-5", base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_tokens=4096)
```

Example model: `openai/gpt-6.1-sol, anthropic/claude-sonnet-5-5`

#### Important

The openai/ or anthropic/ prefix selects the provider in CrewAI; the request sends the id without the prefix. For OpenAI, the URL includes /v1; for Anthropic, it does not. The documentation also describes the custom\_openai=True flag for an arbitrary OpenAI-compatible gateway. Anthropic requires max\_tokens.

[Full guide →](https://ailoot.ai/docs/en/integrations/crewai/)[Application documentation ↗](https://docs.crewai.com/en/concepts/llms)

GG

### [Google GenAI SDK (Python)](https://ailoot.ai/docs/en/integrations/google-genai-python/)

SDK

Gemini

The official Google library for the Gemini API.

[Learn more →](https://ailoot.ai/docs/en/integrations/google-genai-python/)

#### Where to set it up

genai.Client(api\_key=..., http\_options=types.HttpOptions(base\_url=...))

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```python
import os
from google import genai
from google.genai import types
client = genai.Client(
    api_key=os.environ["AILOOT_API_KEY"],
    http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))
r = client.models.generate_content(model="gemini-3.6-flash", contents="Hello")
print(r.text)
```

Example model: `gemini-3.6-flash, gemini-3.1-pro`

#### Important

Use a URL without /v1beta: the SDK builds /v1beta/models/{model}:generateContent. The key is sent in the x-goog-api-key header, which Ailoot accepts. Only models supporting the Gemini format are available. The documentation for the JavaScript version (@google/genai) does not describe a custom endpoint, so it is not included here.

[Full guide →](https://ailoot.ai/docs/en/integrations/google-genai-python/)[Application documentation ↗](https://github.com/googleapis/python-genai#custom-base-url)

Li

### [LiteLLM](https://ailoot.ai/docs/en/integrations/litellm/)

SDK

OpenAI Chat

A unified Python interface for dozens of providers.

[Learn more →](https://ailoot.ai/docs/en/integrations/litellm/)

#### Where to set it up

litellm.completion(model="openai/\<id\>", api\_base=..., api\_key=...)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```python
import os
import litellm
r = litellm.completion(
    model="openai/claude-sonnet-5-5",
    api_base="https://api.ailoot.ai/v1",
    api_key=os.environ["AILOOT_API_KEY"],
    messages=[{"role": "user", "content": "Hello"}])
print(r.choices[0].message.content)
# embeddings: litellm.embedding(model="openai/nemotron-3-embed", api_base="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], input=["text"])
```

Example model: `openai/claude-sonnet-5-5, openai/qwen3.8-max, openai/nemotron-3-embed`

#### Important

The openai/ prefix selects the OpenAI-compatible protocol; Ailoot receives the id without the prefix. LiteLLM adds /chat/completions and /embeddings automatically. According to the documentation, if you get a Not Found error, the URL should end with /v1.

[Full guide →](https://ailoot.ai/docs/en/integrations/litellm/)[Application documentation ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

LP

### [LiteLLM Proxy](https://ailoot.ai/docs/en/integrations/litellm-proxy/)

Custom gateway

OpenAI Chat

Your own gateway with keys, limits, and logs on top of Ailoot.

[Learn more →](https://ailoot.ai/docs/en/integrations/litellm-proxy/)

#### Where to set it up

config.yaml → model\_list → litellm\_params (model, api\_base, api\_key); start with litellm --config config.yaml

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```yaml
model_list:
  - model_name: claude-sonnet
    litellm_params:
      model: openai/claude-sonnet-5-5
      api_base: https://api.ailoot.ai/v1
      api_key: os.environ/AILOOT_API_KEY
  - model_name: gpt-sol
    litellm_params:
      model: openai/gpt-6.1-sol
      api_base: https://api.ailoot.ai/v1
      api_key: os.environ/AILOOT_API_KEY

# run: litellm --config config.yaml
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `openai/claude-sonnet-5-5, openai/gpt-6.1-sol`

#### Important

The proxy is useful if you want to issue your team internal keys backed by a single Ailoot key. Charges in Ailoot are attributed to the key specified in api\_key. Use a URL with /v1.

[Full guide →](https://ailoot.ai/docs/en/integrations/litellm-proxy/)[Application documentation ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

Ll

### [LlamaIndex](https://ailoot.ai/docs/en/integrations/llamaindex/)

Framework

OpenAI Chat

A framework for searching your data and RAG.

[Learn more →](https://ailoot.ai/docs/en/integrations/llamaindex/)

#### Where to set it up

llama-index-llms-openai-like package, OpenAILike(api\_base=..., api\_key=..., model=..., is\_chat\_model=True) class

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
pip install llama-index-llms-openai-like
```

```python
import os
from llama_index.llms.openai_like import OpenAILike
llm = OpenAILike(
    model="deepseek-v4-pro",
    api_base="https://api.ailoot.ai/v1",
    api_key=os.environ["AILOOT_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=128000)
print(llm.complete("Hello"))
```

Example model: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Important

Use a URL with /v1. is\_chat\_model=True is required; otherwise, the class uses the legacy /completions endpoint. Set is\_function\_calling\_model=True so agents can use tools. Set context\_window according to the model card in the Ailoot catalog.

[Full guide →](https://ailoot.ai/docs/en/integrations/llamaindex/)[Application documentation ↗](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

Ma

### [Mastra](https://ailoot.ai/docs/en/integrations/mastra/)

Agent framework

OpenAI ChatOpenAI Responses

A TypeScript framework for agents and workflows.

[Learn more →](https://ailoot.ai/docs/en/integrations/mastra/)

#### Where to set it up

In Agent: model: { id: "\<provider\>/\<model\>", url: "\<baseURL\>", apiKey, api?: "chat" | "responses" }

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```js
import { Agent } from "@mastra/core/agent";
const agent = new Agent({
  id: "ailoot-agent",
  name: "Ailoot Agent",
  instructions: "Respond in Russian",
  model: {
    id: "ailoot/claude-sonnet-5-5",
    url: "https://api.ailoot.ai/v1",
    apiKey: process.env.AILOOT_API_KEY
    // api: "responses"  // only for models with the responses method
  }
});
```

The key is read from the variable `AILOOT_API_KEY` — set it before starting:

```bash
export AILOOT_API_KEY="sk-..."   # add to ~/.zshrc or ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # then restart the terminal
```

Example model: `ailoot/claude-sonnet-5-5, ailoot/gpt-6.1-sol`

#### Important

Set url to the base URL with /v1, not the full /chat/completions path. Chat Completions is the default; api: "responses" switches to the Responses API. The id form "provider/model" sends the bare model ID to the gateway. The documentation shows apiKey in the model object in an example with headers; its use alongside url is not described separately.

[Full guide →](https://ailoot.ai/docs/en/integrations/mastra/)[Application documentation ↗](https://mastra.ai/models)

OA

### [OpenAI Agents SDK](https://ailoot.ai/docs/en/integrations/openai-agents-sdk/)

Agent framework

OpenAI ChatOpenAI Responses

OpenAI’s library for multi-agent workflows.

[Learn more →](https://ailoot.ai/docs/en/integrations/openai-agents-sdk/)

#### Where to set it up

AsyncOpenAI(base\_url=..., api\_key=...) + OpenAIChatCompletionsModel(model=..., openai\_client=client), or set\_default\_openai\_client(client) globally

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```python
import os
from agents import Agent, Runner, AsyncOpenAI, OpenAIChatCompletionsModel, set_tracing_disabled
set_tracing_disabled(disabled=True)
client = AsyncOpenAI(max_retries=0, base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
model = OpenAIChatCompletionsModel(model="claude-sonnet-5-5", openai_client=client)
agent = Agent(name="Assistant", instructions="Respond in Russian", model=model)
print(Runner.run_sync(agent, "Hello").final_output)
```

Example model: `claude-sonnet-5-5, gpt-6.1-sol`

#### Important

Use an address with /v1. Disable tracing with set\_tracing\_disabled(True): otherwise, the SDK will attempt to send traces to OpenAI without an OpenAI key. Chat Completions is available only if the model lists this method in the catalog and the method is available to your key; Responses (the SDK default) is available only for models that list the responses method in the catalog. OpenAI’s built-in tools (web search and files) are not guaranteed through a third-party gateway.

[Full guide →](https://ailoot.ai/docs/en/integrations/openai-agents-sdk/)[Application documentation ↗](https://openai.github.io/openai-agents-python/models/)

PA

### [Pydantic AI](https://ailoot.ai/docs/en/integrations/pydantic-ai/)

Agent framework

OpenAI ChatOpenAI Responses

A typed Python agent framework.

[Learn more →](https://ailoot.ai/docs/en/integrations/pydantic-ai/)

#### Where to set it up

OpenAIProvider(base\_url=..., api\_key=...) with OpenAIChatModel for Chat Completions or OpenAIResponsesModel for Responses, or the OPENAI\_BASE\_URL variable

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```python
import os
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider
model = OpenAIChatModel("deepseek-v4-pro",
    provider=OpenAIProvider(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"]))
agent = Agent(model)
print(agent.run_sync("Hello").output)
```

Example model: `deepseek-v4-pro, gpt-6.1-sol (for OpenAIResponsesModel)`

#### Important

Include /v1 in the URL. The documentation defaults to OpenAIResponsesModel: use it only for models with the responses method; use OpenAIChatModel for the others.

[Full guide →](https://ailoot.ai/docs/en/integrations/pydantic-ai/)[Application documentation ↗](https://pydantic.dev/docs/ai/models/openai/)

## Automation

No-code workflows, chain builders, bots, and smart home systems.

N8

### [n8n](https://ailoot.ai/docs/en/integrations/n8n/)

No-code automation

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Workflow automation with AI agent nodes.

[Learn more →](https://ailoot.ai/docs/en/integrations/n8n/)

#### Where to set it up

Credentials → OpenAI → Base URL (default https://api.openai.com/v1); Credentials → Anthropic → Base URL (default https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (default https://generativelanguage.googleapis.com). Then use OpenAI Chat Model / Anthropic Chat Model / Google Gemini Chat Model nodes

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
OpenAI credential:
  API Key: sk-...
  Base URL: https://api.ailoot.ai/v1
Anthropic credential:
  API Key: sk-...
  Base URL: https://api.ailoot.ai
Google Gemini(PaLM) Api credential:
  Host: https://api.ailoot.ai
  API Key: sk-...
OpenAI Chat Model node → Model: By ID → gpt-6.1-sol (Use Responses API toggle — only for models with the responses method)
```

Example model: `gpt-6.1-sol / deepseek-v4-pro (OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Important

Credential checks call /models for OpenAI, /v1/models for Anthropic, and /v1beta/models for Gemini; Ailoot provides all three paths. The n8n documentation pages do not describe Base URL, but the field exists in the credentials themselves: OpenAiApi.credentials.ts and AnthropicApi.credentials.ts label it “Override the default base URL for the API”. On n8n Cloud, do not select “Use Gateway credits”, or requests will bypass Ailoot.

[Full guide →](https://ailoot.ai/docs/en/integrations/n8n/)[Application documentation ↗](https://github.com/n8n-io/n8n/blob/master/packages/nodes-base/credentials/OpenAiApi.credentials.ts)

Di

### [Dify](https://ailoot.ai/docs/en/integrations/dify/)

LLM application platform

OpenAI Chat

An AI application platform for chatbots, agents, and knowledge bases.

[Learn more →](https://ailoot.ai/docs/en/integrations/dify/)

#### Where to set it up

Integrations → Model Provider → install the OpenAI-API-compatible plugin → Add Model (fields: Model Type, Model Name, API Key, API Base URL, Completion mode, Model context size)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Model Type: LLM
Model Name: claude-sonnet-5-5
API Key: sk-...
API Base URL: https://api.ailoot.ai/v1
Completion mode: Chat
Model context size: as listed on the model card in the Ailoot catalog

For Text Embedding:
Model Name: nemotron-3-embed
API Base URL: https://api.ailoot.ai
```

Example model: `claude-sonnet-5-5, gpt-6.1-sol, qwen3.8-max; nemotron-3-embed (embeddings)`

#### Important

Only the workspace owner and administrators can manage providers. According to the plugin README, the URL includes /v1 for LLMs; for embeddings, rerank, STT, and TTS, the plugin appends the API version, so use a URL without /v1 (otherwise the result will be /v1/v1). Add each Ailoot model as a separate entry; enable image input and streaming output in the model settings.

[Full guide →](https://ailoot.ai/docs/en/integrations/dify/)[Application documentation ↗](https://github.com/langgenius/dify-official-plugins/tree/main/models/openai_api_compatible)

Fl

### [Flowise](https://ailoot.ai/docs/en/integrations/flowise/)

Chain builder

OpenAI Chat

A visual builder for chains and agents.

[Learn more →](https://ailoot.ai/docs/en/integrations/flowise/)

#### Where to set it up

ChatOpenAI or ChatOpenAI Custom node → Connect Credential (key) → Additional Parameters → Base Path (and Base Options for headers)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Credential (OpenAI API): sk-...
ChatOpenAI Custom node:
  Model Name: deepseek-v4-pro
  Additional Parameters → Base Path: https://api.ailoot.ai/v1
```

Example model: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Important

ChatOpenAI has a fixed model list, so use ChatOpenAI Custom for arbitrary Ailoot ids; it lets you enter the model name manually. Base Path includes /v1. For embeddings, use the OpenAI Embeddings Custom node.

[Full guide →](https://ailoot.ai/docs/en/integrations/flowise/)[Application documentation ↗](https://docs.flowiseai.com/integrations/langchain/chat-models/azure-chatopenai)

HA

### [Home Assistant](https://ailoot.ai/docs/en/integrations/home-assistant/)

Smart home

OpenAI Chat

A smart-home voice assistant through Extended OpenAI Conversation.

[Learn more →](https://ailoot.ai/docs/en/integrations/home-assistant/)

#### Where to set it up

Install through HACS (Custom repository) or copy custom\_components/extended\_openai\_conversation → restart → Settings → Devices & Services → Add Integration → Extended OpenAI Conversation (API Key, Base Url) → Settings → Voice Assistants → Conversation agent

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
API Key: sk-...
Base Url: https://api.ailoot.ai/v1
Options → Chat Model: gpt-6.1-sol
Voice Assistants → Conversation agent: Extended OpenAI Conversation
```

Example model: `gpt-6.1-sol, claude-sonnet-5-5`

#### Important

This is a third-party component, not an official integration. Device control uses function calling (tools) in Chat Completions, so choose models that support tools. The official OpenAI Conversation integration does not support a custom endpoint.

[Full guide →](https://ailoot.ai/docs/en/integrations/home-assistant/)[Application documentation ↗](https://github.com/jekalmin/extended_openai_conversation)

La

### [Langflow](https://ailoot.ai/docs/en/integrations/langflow/)

Chain builder

OpenAI Chat

A visual builder for agents and RAG.

[Learn more →](https://ailoot.ai/docs/en/integrations/langflow/)

#### Where to set it up

Profile → Settings → Model Providers → OpenAI Compatible (Base URL and API Key fields; OPENAI\_COMPATIBLE\_BASE\_URL and OPENAI\_COMPATIBLE\_API\_KEY environment variables). Alternatively: OpenAI component → OpenAI API Base field

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Settings → Model Providers → OpenAI Compatible:
  Base URL: https://api.ailoot.ai/v1
  API Key: sk-...
or through environment variables:
```

```bash
export OPENAI_COMPATIBLE_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_COMPATIBLE_API_KEY="sk-..."
Then select OpenAI Compatible → claude-sonnet-5-5 in the Language Model / Agent components
```

Example model: `claude-sonnet-5-5, gpt-6.1-sol, nemotron-3-embed (Embedding Model)`

#### Important

Langflow tests the connection and fetches the model list from /v1/models. The models appear under Language Models and Embedding Models; you then need to enable the models you want manually. The provider is installed with langflow.

[Full guide →](https://ailoot.ai/docs/en/integrations/langflow/)[Application documentation ↗](https://docs.langflow.org/bundles-openai-compatible)

Ma

### [Make](https://ailoot.ai/docs/en/integrations/make/)

No-code automation

HTTP request

No-code automation: call Ailoot through the HTTP module.

[Learn more →](https://ailoot.ai/docs/en/integrations/make/)

#### Where to set it up

The built-in OpenAI module works only with an OpenAI account. Use HTTP → Make a request: URL, Method, Headers, Body type Raw / JSON

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Module: HTTP → Make a request
URL: https://api.ailoot.ai/v1/chat/completions
Method: POST
Headers:
  Authorization: Bearer sk-...
  Content-Type: application/json
Body (JSON):
{"model":"gpt-6.1-sol","messages":[{"role":"user","content":"{{1.text}}"}]}
Parse response: Yes → the response is in choices[].message.content
```

Example model: `gpt-6.1-sol, claude-sonnet-5-5`

#### Important

This is a general-purpose HTTP module, not a dedicated Ailoot provider: its documentation allows any HTTPS URL. Store the key in an API-key connection, as Make recommends, rather than passing it in headers. Make does not need streaming output; omit stream.

[Full guide →](https://ailoot.ai/docs/en/integrations/make/)[Application documentation ↗](https://apps.make.com/http)

T

### [Telegram bot](https://ailoot.ai/docs/en/integrations/telegram-bot/)

Bots

OpenAI Chat

Your own Telegram bot using the OpenAI SDK.

[Learn more →](https://ailoot.ai/docs/en/integrations/telegram-bot/)

#### Where to set it up

Telegram frameworks have no built-in LLM layer: the message handler calls the OpenAI SDK with the Ailoot base\_url, or the Anthropic SDK with base\_url without /v1

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

Save the Python code as ailoot-telegram-bot.py. Install the dependencies, set both environment variables, then run the file. Send Hello to your bot and check for a text reply. If the request fails, keep its Request ID and check the original result before sending another generation.

```bash
python3 -m pip install "aiogram>=3,<4" openai
```

`ailoot-telegram-bot.py`

```python
import asyncio
import os
from aiogram import Bot, Dispatcher, F
from aiogram.types import Message
from openai import AsyncOpenAI, APIError

async def main():
    dp = Dispatcher()
    async with AsyncOpenAI(
        base_url="https://api.ailoot.ai/v1",
        api_key=os.environ["AILOOT_API_KEY"],
        max_retries=0,
    ) as llm:
        @dp.message(F.text)
        async def reply(message: Message):
            try:
                result = await llm.chat.completions.create(
                    model="claude-sonnet-5-5",
                    messages=[{"role": "user", "content": message.text}],
                )
                content = result.choices[0].message.content or "—"
                for start in range(0, len(content), 4000):
                    await message.answer(content[start:start + 4000])
            except APIError as error:
                await message.answer(
                    f"{type(error).__name__}; Request ID: "
                    f"{getattr(error, 'request_id', None) or '—'}"
                )
        bot = Bot(token=os.environ["TELEGRAM_BOT_TOKEN"])
        await dp.start_polling(bot)

if __name__ == "__main__":
    asyncio.run(main())
```

```bash
export AILOOT_API_KEY="sk-..."
export TELEGRAM_BOT_TOKEN="<TELEGRAM_BOT_TOKEN>"
python3 ailoot-telegram-bot.py
```

Example model: `claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-flash`

#### Important

Telegram frameworks have no built-in AI layer: configure the Ailoot URL in the OpenAI SDK inside the bot. With a zero balance, Ailoot returns a clear 402 error with a Request ID; show it to the bot user instead of crashing.

[Full guide →](https://ailoot.ai/docs/en/integrations/telegram-bot/)[Application documentation ↗](https://github.com/openai/openai-python)

Za

### [Zapier](https://ailoot.ai/docs/en/integrations/zapier/)

No-code automation

HTTP request

Automation: call Ailoot through Webhooks by Zapier.

[Learn more →](https://ailoot.ai/docs/en/integrations/zapier/)

#### Where to set it up

Zapier’s ChatGPT (OpenAI) application works only with OpenAI. Use Webhooks by Zapier → Custom Request (Method, URL, Data, Headers)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Action: Webhooks by Zapier → Custom Request
Method: POST
URL: https://api.ailoot.ai/v1/chat/completions
Data (raw JSON):
{"model":"claude-sonnet-5-5","messages":[{"role":"user","content":"Hello"}]}
Headers:
  Authorization | Bearer sk-...
  Content-Type | application/json
```

Example model: `claude-sonnet-5-5, gpt-6.1-sol`

#### Important

This is a general-purpose HTTP request. Zapier has no ready-made provider with a base URL field. Custom Request sends Data unchanged without parsing it, so validate the JSON beforehand. Webhooks by Zapier is available on paid Zapier plans.

[Full guide →](https://ailoot.ai/docs/en/integrations/zapier/)[Application documentation ↗](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zap-workflows)

## Under review

Settings with unconfirmed details; check them against the application window.

AC

### [Antigravity CLI](https://ailoot.ai/docs/en/integrations/antigravity-cli/)

Terminal agent

Under review

Gemini

Google Antigravity’s command-line agent using Gemini format.

[Learn more →](https://ailoot.ai/docs/en/integrations/antigravity-cli/)

#### Where to set it up

~/.gemini/antigravity-cli/settings.json → "modelProvider": "gemini"; GEMINI\_API\_KEY and GOOGLE\_GEMINI\_BASE\_URL environment variables

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1beta/models/{model}:generateContent, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

`~/.gemini/antigravity-cli/settings.json`

```json
{
  "modelProvider": "gemini"
}
```

```bash
export AILOOT_API_KEY="sk-..."
# in the terminal:
export GEMINI_API_KEY="$AILOOT_API_KEY"
export GOOGLE_GEMINI_BASE_URL=https://api.ailoot.ai
agy --model gemini-3.8-flash
```

Example model: `gemini-3.8-flash`

#### Important

The protocol is native Gemini REST (streamGenerateContent, key in X-Goog-Api-Key), using the https://api.ailoot.ai/v1beta/... path. For each question, agy sends two requests: the conversation title and the response itself. The agent reserves substantially more for each step than a regular chat, so keep extra funds in your balance. This card is in the “Under review” section: the configuration is based on the documentation, and a live client run through Ailoot has not yet been performed. If modelProvider = gemini and GEMINI\_API\_KEY is empty, the CLI will not start.

[Full guide →](https://ailoot.ai/docs/en/integrations/antigravity-cli/)[Application documentation ↗](https://antigravity.google/docs/cli/install/)

CC

### [Cline CLI](https://ailoot.ai/docs/en/integrations/cline-cli/)

Terminal agent

Under review

OpenAI Chat

The command-line version of the Cline agent.

[Learn more →](https://ailoot.ai/docs/en/integrations/cline-cli/)

#### Where to set it up

cline auth → custom API providers → OpenAI Compatible: Base URL, API Key, Model ID; the -P/--provider flag selects the provider

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```bash
cline auth
# API Provider: OpenAI Compatible
# Base URL:     https://api.ailoot.ai/v1
# API Key:      sk-...
# Model ID:     claude-sonnet-5-5
cline "Run the tests and fix the errors"
```

Example model: `claude-sonnet-5-5`

#### Important

The Base URL / API Key / Model ID fields are described in Cline's documentation for OpenAI Compatible. The CLI documentation does not list the exact labels in the cline auth wizard, so check the screen.

[Full guide →](https://ailoot.ai/docs/en/integrations/cline-cli/)[Application documentation ↗](https://docs.cline.bot/provider-config/openai-compatible)

CJ

### [Copilot for JetBrains](https://ailoot.ai/docs/en/integrations/copilot-jetbrains-byok/)

Editor extension

Under review

OpenAI Chat

A custom model endpoint in Copilot for JetBrains IDEs.

[Learn more →](https://ailoot.ai/docs/en/integrations/copilot-jetbrains-byok/)

#### Where to set it up

Language Models → Add Models… → Add Custom Endpoint Provider: Provider Name, API Key, API Type (Chat Completions)

#### Configuration

[JetBrains AI Assistant](https://ailoot.ai/docs/en/integrations/jetbrains-ai-assistant/)

#### Important

GitHub confirms custom endpoint support. Its official screenshot shows Provider Name, API Key and API Type: Chat Completions, but no endpoint URL example. A ready Ailoot configuration is therefore not provided here. JetBrains AI Assistant is the documented alternative in this IDE. Ask the official plugin support team to clarify the endpoint URL requirements.

[Full guide →](https://ailoot.ai/docs/en/integrations/copilot-jetbrains-byok/)[Application documentation ↗](https://github.blog/changelog/2026-07-14-github-copilot-for-jetbrains-expands-byok-capabilities/)

Cu

### [Cursor](https://ailoot.ai/docs/en/integrations/cursor/)

Code editor

Under review

OpenAI Chat

Cursor editor: a custom OpenAI endpoint for chat.

[Learn more →](https://ailoot.ai/docs/en/integrations/cursor/)

#### Where to set it up

Cursor Settings → Models → API Keys → OpenAI API Key + “Override OpenAI Base URL” toggle; then add the model ID to your custom models.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
OpenAI API Key:            sk-...
Override OpenAI Base URL:  https://api.ailoot.ai/v1
Custom model:               gpt-6.1-sol  (add, enable, select in chat)
```

Example model: `gpt-6.1-sol`

#### Important

Cursor's current official documentation does not describe a custom endpoint: it lists only OpenAI/Anthropic/Google/Azure/Bedrock keys, states that custom keys work only in chat (Tab continues to use Cursor models), and says that all requests go through Cursor's servers (the endpoint must be public; api.ailoot.ai is public). The URL override toggle exists in the interface, but Cursor forum users report issues: it applies to all models, Agent mode may not use a custom key, and the field does not accept input in some 3.15.x builds.

[Full guide →](https://ailoot.ai/docs/en/integrations/cursor/)[Application documentation ↗](https://cursor.com/help/models-and-usage/api-keys)

OT

### [Obsidian Text Generator](https://ailoot.ai/docs/en/integrations/obsidian-text-generator/)

Obsidian plugin

Under review

OpenAI Chat

Template-based text generation in Obsidian notes.

[Learn more →](https://ailoot.ai/docs/en/integrations/obsidian-text-generator/)

#### Where to set it up

Settings \> Text Generator \> LLM Provider: OpenAI Chat (or Custom)

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider: OpenAI Chat
API Key: sk-...
Base Path: https://api.ailoot.ai/v1
Model: gpt-6.1-sol
```

Example model: `gpt-6.1-sol`

#### Important

The plugin documentation mentions a Custom provider but does not describe the URL field or its format. These settings are based on the plugin interface; check your settings window.

[Full guide →](https://ailoot.ai/docs/en/integrations/obsidian-text-generator/)[Application documentation ↗](https://docs.text-gen.com/)

Pe

### [PearAI](https://ailoot.ai/docs/en/integrations/pearai/)

Code editor

Under review

OpenAI Chat

PearAI editor, based on VS Code.

[Learn more →](https://ailoot.ai/docs/en/integrations/pearai/)

#### Where to set it up

Cmd/Ctrl+Shift+P → Open config.json → an entry in models\[\] (PearAI is a Continue fork).

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```json
{
  "models": [
    {
      "title": "Ailoot Claude Sonnet 5.5",
      "provider": "openai",
      "model": "claude-sonnet-5-5",
      "apiBase": "https://api.ailoot.ai/v1",
      "apiKey": "sk-..."
    }
  ]
}
```

Example model: `claude-sonnet-5-5`

#### Important

The official PearAI documentation could not be checked because the documentation site was unavailable, and the repository has not been updated for a long time. The configuration follows Continue’s example; check it in the application.

[Full guide →](https://ailoot.ai/docs/en/integrations/pearai/)[Application documentation ↗](https://github.com/trypear/pearai-app/issues/122)

VS

### [Visual Studio 2026](https://ailoot.ai/docs/en/integrations/visual-studio-2026/)

Code editor

Under review

OpenAI Chat

A custom provider in Copilot Chat for Visual Studio.

[Learn more →](https://ailoot.ai/docs/en/integrations/visual-studio-2026/)

#### Where to set it up

Chat → model picker → Manage models → Add custom model → OpenAI (custom endpoint) → URL, key, and model.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider: OpenAI (custom endpoint)
Endpoint: https://api.ailoot.ai/v1
API key:  sk-...
Model:    gpt-6.1-sol
```

Example model: `gpt-6.1-sol`

#### Important

The Visual Studio blog (29.09.2026) announced custom URLs for OpenAI and Ollama in VS 2026 Stable. The documentation still describes only OpenAI/Anthropic/Google keys without a URL field, so field names and URL format remain unconfirmed. Chat only; unavailable on Copilot Business/Enterprise plans.

[Full guide →](https://ailoot.ai/docs/en/integrations/visual-studio-2026/)[Application documentation ↗](https://devblogs.microsoft.com/visualstudio/visual-studio-september-update-power-your-workflow-with-your-model/)

Vo

### [Void](https://ailoot.ai/docs/en/integrations/void/)

Code editor

Under review

OpenAI Chat

An open-source VS Code-based editor whose development has stopped.

[Learn more →](https://ailoot.ai/docs/en/integrations/void/)

#### Where to set it up

Void Settings → Providers → OpenAI-Compatible → baseURL, API key, model.

#### Configuration

Before starting, request GET /v1/models with your Ailoot key. Choose an exact model ID whose methods include POST /v1/chat/completions, then use that ID in the configuration. For agents, also check tool support and the features required by your client version.

```text
Provider: OpenAI-Compatible
baseURL:  https://api.ailoot.ai/v1   (without /chat/completions)
API key:  sk-...
Model:    claude-sonnet-5-5
```

Example model: `claude-sonnet-5-5`

#### Important

These settings come from Void’s source code, not its user documentation. The Void repository is archived, and the editor is no longer maintained; this is useful only for existing users.

[Full guide →](https://ailoot.ai/docs/en/integrations/void/)[Application documentation ↗](https://github.com/voideditor/void/blob/main/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts)

No results found. If the application supports a custom OpenAI or Anthropic API URL, it will most likely work. Here is [what to enter](https://ailoot.ai/docs/en/keys/).

## Not currently compatible

These applications do not support a custom API URL. Alternatives are listed alongside them.

| Application | Why it is not compatible | What to use instead |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Uses only Cursor models; you cannot set a custom API URL. | Claude Code, Codex CLI, or opencode |
| **Auggie CLI (Augment Code)** | Requires sign-in with an Augment account; you cannot specify a third-party provider. | Claude Code or opencode |
| **Windsurf / Devin Desktop** | Accepts only an Anthropic key for selected Claude models; you cannot set a custom URL. | Cline, Roo Code, or Kilo Code in VS Code |
| **Kiro** | Does not support your own key or a custom API URL. | Cline or Roo Code |
| **Google Antigravity (IDE)** | There is no official setting for a custom provider; we do not recommend third-party patches. | Antigravity CLI or Gemini CLI |
| **Visual Studio with Copilot Business or Enterprise** | Custom models are not available on these Copilot plans. | An individual Copilot plan — see the Visual Studio 2026 integration card |
| **Cursor Tab autocomplete** | Always uses Cursor models, even when you supply your own key. | Cursor chat is configured separately — see the Cursor integration card |
| **Enchanted** | Works only with the Ollama API. | Open WebUI or Chatbox |
| **Smart Connections (Obsidian)** | External APIs are available only with paid Smart Chat Pro. | Obsidian Copilot |
| **Witsy, 5ire** | We could not find official documentation for setting a custom API URL. | Cherry Studio or Jan |
| **Make: built-in OpenAI module** | Connects only to an OpenAI account. | HTTP module → Make a request — see the Make integration card |
| **Zapier: ChatGPT (OpenAI) app** | There is no field for a custom URL. | Webhooks by Zapier → Custom Request — see the Zapier integration card |
| **Home Assistant: OpenAI Conversation** | The built-in integration works only with the OpenAI URL. | Extended OpenAI Conversation from HACS — see the Home Assistant integration card |
| **aiogram, python-telegram-bot, grammY, Telegraf** | Bot frameworks do not connect to models on their own. | OpenAI or Anthropic SDK inside your bot — see the Telegram bot integration card |

## AI API connections and client setup

### How do I set the AI API URL and key in my client?

Agents, editors, chats, and SDKs that accept an Ailoot key. The “Set up” button shows where to enter the URL and key, with a ready-to-copy configuration.

Connect Ailoot to Claude Code, OpenCode, Hermes or your own app.

## The company and its project portfolio

The company and its project portfolio: millions of customers; monthly sales in the billions.

## Buy tokens at a discount.

Subscription discounts for regular use. Promo codes offer up to 50% off token purchases.

Subscription

Choose a discounted plan for your regular requests.

Promo code: up to 50% off

Enter your code at checkout. The price updates to reflect the current promotion.

Spending in your history

The model, tokens and amount are recorded for each request.

[Choose a subscription](https://ailoot.ai/docs/en/billing/subscriptions/) · [View model prices](https://ailoot.ai/models/en/)

## Connect the API to a product you sell.

Use Ailoot in SaaS, apps and bots under its official service offer and licence agreement. Request a reseller licence for resale.

Commercial application

Add text, image, video and audio generation to paid features in your service.

Reseller licence

Send a description of your project and how you provide access. Request written terms for use and resale.

Documents on the website

The service offer, licence agreement and data processing policy are available before you connect.

[Request a reseller licence](mailto:support@ailoot.ai) · [Service offer and licence agreement](https://ailoot.ai/legal/offer?lang=en)

## Questions

Which client format should I choose?

Choose the OpenAI, Anthropic or Gemini format supported by your client. Check the Ailoot model card for a compatible API method and model ID; one supported format does not mean every model supports all formats.

What do I need to configure in my client?

Set the Ailoot API key, API address and a model ID compatible with the client method. OpenAI SDK uses https://api.ailoot.ai/v1; Anthropic and Gemini SDK use https://api.ailoot.ai. Keep the request fields from the example for that format.

How do I send my first API request?

Create an Ailoot API key. Set https://api.ailoot.ai/v1 for OpenAI SDK, or https://api.ailoot.ai for Anthropic and Gemini SDK. GET /v1/models is free and lists models available to your key; then use the example for the selected model and API method.

What should I check when a connected client fails?

Check that the client sends the expected OpenAI, Anthropic or Gemini format to the matching API address with your Ailoot API key. Confirm the model ID and method, then compare the returned error with the client guide. Send the error and request ID to support@ailoot.ai without sharing your key.

Can I use Ailoot in a paid product?

Yes. Connect the API to your SaaS, app or bot under the Ailoot service offer and licence agreement. For resale, request written terms and a reseller licence for your project.

How do I request a reseller licence?

Email support@ailoot.ai with what your product does, who uses it, and how you provide access. Request a reseller licence and written terms for your project.

## Ailoot · The company and its project portfolio





Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control.





The company and its project portfolio: millions of customers; monthly sales in the billions.





Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.