ApiClo Docs

Good for autonomous coding tasks in VS Code. ApiClo can be connected in two ways.

Option A: OpenAI Compatible

1. 1

   Install Cline from the VS Code Marketplace and open Settings / API Configuration.

2. 2

   Select OpenAI Compatible as API Provider.

3. 3

   Set the full Base URL with /v1: https://apiclo.com/v1.

4. 4

   API Key: your sk-hub key. Model ID: claude-sonnet-5 or claude-opus-4-8.

5. 5

   Save the profile and first send the test: Reply only OK.

Option B: Anthropic Messages for native mode

1. 1

   If your Cline build requires the Anthropic provider, enable Use custom base URL.

2. 2

   Custom Base URL: https://apiclo.com . Do not add /v1 here; Cline calls /v1/messages itself.

3. 3

   API Key: your sk-hub key. Model: claude-sonnet-5 or claude-opus-4-8.

4. 4

   If the Anthropic native mode is unstable, return to Option A OpenAI-compatible.

After saving, send: Reply only OK. Second test: Look at the current folder and say whether README.md exists; do not change anything.

Images: select a vision-capable model and enable Supports images/Vision if your Cline version exposes that toggle. Start a new task after changing it and attach a PNG with a text question.

Roo Code uses almost the same setup as Cline, but the provider profile labels may differ.

1. 1

   Install Roo Code from VS Code Extensions and open the Roo Code panel.

2. 2

   Create an API key in ApiClo under API Keys.

3. 3

   Open API Configuration / Provider / Profile.

4. 4

   By default, choose an OpenAI-compatible profile: Base URL https://apiclo.com/v1 and an ApiClo model id.

5. 5

   Use Anthropic + custom base URL https://apiclo.com without /v1 only for native/advanced mode.

6. 6

   Save the profile, verify OK, then run a file task.

7. 7

   Second test: ask Roo to read the current folder and say whether README.md exists, without editing files.

Images: enable Vision/Supports images in the model profile when available. If Roo hides the attachment before the request, verify the same model through OpenCode or Harness with an explicit capability.

For Kilo, use Custom Provider. Unlike Cline/Roo, the Base URL is usually entered with /v1.

1. 1

   Install Kilo Code from VS Code Extensions and open Settings / API Configuration.

2. 2

   Get an sk-hub API key in ApiClo -> API Keys.

3. 3

   Create a Custom Provider: Provider ID apiclaude, Display Name ApiClo.

4. 4

   For Claude models, choose Provider API: OpenAI Compatible and Base URL https://apiclo.com/v1 by default.

5. 5

   Use Provider API: Anthropic Messages only when Kilo explicitly needs native Messages mode.

6. 6

   Model ID: claude-sonnet-5, claude-opus-4-8, or claude-fable-5-1.

7. 7

   Save the provider and run two tests: Reply only OK; then read the project file list without edits.

Images: set attachment: true and modalities with input [text, image], output [text] on the custom model. Without modalities, an unknown model is treated as text-only.

"attachment": true,
"modalities": {
  "input": ["text", "image"],
  "output": ["text"]
}

Continue is configured through config.yaml. Give the model chat, edit, apply, and summarize roles.

1. 1

   Install Continue and open the configuration: Continue -> Settings -> Open config.yaml.

2. 2

   Save the old config.yaml before replacing it if you already have custom models.

3. 3

   Paste the block below and replace YOUR_API_KEY with your sk-hub key.

4. 4

   Restart Continue or run Reload Window in the IDE.

5. 5

   Test chat, edit, and apply on a small file before a heavy task.

name: ApiClo
version: 1.0.0
schema: v1
models:
  - name: Claude Sonnet 5
    provider: openai
    model: claude-sonnet-5
    apiBase: https://apiclo.com/v1
    apiKey: YOUR_API_KEY
    capabilities:
      - tool_use
    roles:
      - chat
      - edit
      - apply
      - summarize
    defaultCompletionOptions:
      temperature: 0
context:
  - provider: code
  - provider: docs
  - provider: diff
  - provider: terminal
  - provider: problems
  - provider: folder
  - provider: codebase

This example does not impose hard contextLength or maxTokens values. Continue uses the selected model's capabilities and shows the active configuration in Continue Console → Options.

In a long Agent session, click Compact conversation, the converging-arrows icon under the latest response. Once context reaches 60%, the same action is available from the context indicator beside the input. Continue keeps a technical summary and sends it with only the newer turns. This compacts history rather than truncating the active task. After compaction, inspect the next request in Continue Console: it should contain the summary and only newer turns, not hundreds of old tool_result blocks.

If Continue rejects provider: openai, use its OpenAI-compatible/custom provider with the same apiBase/apiKey/model. For model, use claude-sonnet-5 or claude-opus-4-8 without the apiclaude/ prefix.

Images: enable image input/vision for the selected custom model in your Continue version. If the field is unavailable, update Continue; a text-only request does not verify attachment delivery.

For VS Code built-in Custom Endpoint, add models to the user configuration file.

1. 1

   Open the VS Code User settings folder and create chatLanguageModels.json if it does not exist.

2. 2

   Paste the JSON below and replace YOUR_API_KEY with your sk-hub key.

3. 3

   Check that url ends with /v1/chat/completions.

4. 4

   Run Developer: Reload Window.

5. 5

   In VS Code chat, choose Claude Sonnet 5 and send the test Reply only OK.

[
  {
    "name": "ApiClo",
    "vendor": "customendpoint",
    "apiKey": "YOUR_API_KEY",
    "apiType": "chat-completions",
    "models": [
      {
        "id": "claude-sonnet-5",
        "name": "Claude Sonnet 5",
        "url": "https://apiclo.com/v1/chat/completions",
        "toolCalling": true,
        "vision": true,
        "maxInputTokens": 1000000,
        "maxOutputTokens": 64000,
        "streaming": true
      },
      {
        "id": "claude-opus-4-8",
        "name": "Claude Opus 4.8",
        "url": "https://apiclo.com/v1/chat/completions",
        "toolCalling": true,
        "vision": true,
        "maxInputTokens": 1000000,
        "maxOutputTokens": 64000,
        "streaming": true
      }
    ]
  }
]

Use Cursor-safe IDs so Cursor does not replace them with built-in model names.

1. 1

   Open Cursor Settings → Models → API Keys and save your ApiClo sk-hub key under OpenAI API Key.

2. 2

   Enable Override OpenAI Base URL and enter exactly https://apiclo.com/v1.

3. 3

   Add one of the exact custom IDs below. They appear in /v1/models and use the same routing, fallback, and billing as the original model.

4. 4

   Select the exact apiclo-* entry, not Cursor's built-in GPT-5.6 Sol or Claude entry.

5. 5

   The setup is the same on macOS and Windows. Cursor Tab and other specialized features may continue to use Cursor's own models.

6. 6

   Send Reply only OK. If the request does not appear in ApiClo Logs, update Cursor and verify that the selected model is the custom apiclo-* entry.

ApiClo supports both /v1/chat/completions and /v1/responses for these IDs. If an error remains, send support the new Cursor Request ID and exact UTC time.

Trae connects through Settings -> Models -> Add Model -> Custom Config.

1. 1

   Install Trae and sign in; otherwise the Models section may be hidden.

2. 2

   Open Settings -> Models -> Add Model -> Custom Config.

3. 3

   For Claude, choose API Format Anthropic Messages, URL https://apiclo.com or https://apiclo.com/v1 if Trae asks for the full /v1 endpoint.

4. 4

   For OpenAI Completions, use https://apiclo.com/v1 and model id claude-sonnet-5.

5. 5

   Paste the API Key, save the model, and run the Reply only OK test.

6. 6

   If Trae shows an empty answer, reduce max output and check the exact API Format.

Images: select a vision-capable model and enable multimodal/vision/attachments in Custom Config if Trae exposes that option. After saving, always run a separate image + text test.

Connect ApiClo as an OpenAI-compatible provider.

1. 1

   Open provider admin settings or the env configuration for your self-hosted UI.

2. 2

   Choose an OpenAI-compatible provider.

3. 3

   Set OPENAI_API_BASE_URL=https://apiclo.com/v1 and OPENAI_API_KEY=sk-hub-...

4. 4

   Add DEFAULT_MODEL=claude-sonnet-5 or choose the model in the UI.

5. 5

   Restart the UI container/process and send a short test.

Images: in Open WebUI or LibreChat enable vision capability on the custom model/connection. Having an API route alone does not make the UI attach a file.

If the UI adds /v1 itself, use root https://apiclo.com or remove the extra /v1 from the setting.

Recommended quick path: the custom provider lives in opencode.json, and vision is declared in model capabilities.

1. 1

   Install OpenCode v2 from the official guide: macOS/Linux — npm install -g @opencode/cli; Windows — use the standalone CLI binary from OpenCode.

2. 2

   Create opencode.json in the project root and paste the configuration below.

3. 3

   Set APICLO_API_KEY in the OpenCode process environment; do not put the key in the project config.

4. 4

   Declare each model's actual capabilities. OpenCode v2 assumes text+image for an unknown model, but that is a fallback assumption, not an API check.

5. 5

   Run opencode, verify a short text response, then attach a small PNG/JPEG and ask it to read visible text.

macOS / Linux:

{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "apiclaude": {
      "name": "ApiClo",
      "env": ["APICLO_API_KEY"],
      "package": "@opencode/ai/providers/openai-compatible",
      "settings": {
        "baseURL": "https://apiclo.com/v1"
      },
      "models": {
        "gpt-6-astra": {
          "name": "GPT 6 Astra",
          "capabilities": {
            "tools": true,
            "input": ["text", "image"],
            "output": ["text"]
          },
          "limit": {
            "context": 200000,
            "output": 128000
          }
        },
        "claude-fable-5-1": {
          "name": "Claude Fable 5.1",
          "capabilities": {
            "tools": true,
            "input": ["text", "image"],
            "output": ["text"]
          },
          "limit": {
            "context": 1000000,
            "output": 128000
          }
        }
      }
    }
  },
  "model": "apiclaude/gpt-6-astra"
}

This example targets OpenCode v2. Declare actual capabilities for other models; the v1 config is not interchangeable. On Windows, download the standalone binary below. OpenCode v2

Harness supports ApiClo as a custom OpenAI-compatible provider. Image input is enabled separately on each model.

1. 1

   Install DeepSeek Harness from its official instructions. In Settings → Models choose Add model provider → Custom model API.

2. 2

   Provider ID: apiclo; Display name: ApiClo; Base URL: https://apiclo.com/v1; API protocol: openai-completions.

3. 3

   Use the APICLO_API_KEY environment variable. If Fetch available models does not list an ID, add the model manually; configure its input types separately.

4. 4

   In Model options enable Text and Image. In the profile this is input: [text, image] on that model.

5. 5

   The change applies to the next request without a restart. If a problematic image remains in the session history, create a new session.

6. 6

   Test text first, then PNG/JPEG. If Harness says model does not support images before the request, the capability still is not saved on the selected model.

For the standard dsh web launch, use $DSH_HOME/profiles/web/cordis.patch.yml; replace web with your profile name otherwise. Preserve other entries when editing an existing file.

- id: llm-pi-ai
  config:
    providers:
      apiclo:
        apiKeyEnv: APICLO_API_KEY
        api: openai-completions
        baseURL: https://apiclo.com/v1
        models:
          - id: gpt-6-astra
            input: [text, image]
          - id: claude-fable-5-1
            input: [text, image]

# macOS / Linux
export APICLO_API_KEY="sk-hub-..."
dsh web

# Windows PowerShell
$env:APICLO_API_KEY="sk-hub-..."
dsh web

Claude Code usually expects an Anthropic-compatible base URL without /v1.

1. 1

   Check Node.js 18+: node --version.

2. 2

   Install Claude Code: npm install -g @anthropic-ai/claude-code@latest.

3. 3

   Check the install: claude --version.

4. 4

   For ApiClo, use ANTHROPIC_AUTH_TOKEN + ANTHROPIC_BASE_URL; ANTHROPIC_API_KEY is only for clients that require x-api-key.

5. 5

   Set CLAUDE_CODE_AUTO_COMPACT_WINDOW=180000 so Claude Code summarizes a long session before the 200k boundary. This does not limit response size.

6. 6

   First verify the gateway with a direct /v1/messages request, then start claude from the same shell session.

7. 7

   In Claude Code, run /status and confirm it shows the ApiClo base URL and active token source.

# macOS / Linux
export ANTHROPIC_AUTH_TOKEN="sk-hub-..."
export ANTHROPIC_BASE_URL="https://apiclo.com"
export ANTHROPIC_MODEL="claude-sonnet-5"
export CLAUDE_CODE_AUTO_COMPACT_WINDOW="180000"
claude

# Windows PowerShell
$env:ANTHROPIC_AUTH_TOKEN="sk-hub-..."
$env:ANTHROPIC_BASE_URL="https://apiclo.com"
$env:ANTHROPIC_MODEL="claude-sonnet-5"
$env:CLAUDE_CODE_AUTO_COMPACT_WINDOW="180000"
claude

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://apiclo.com",
    "ANTHROPIC_AUTH_TOKEN": "sk-hub-...",
    "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "180000"
  }
}

# macOS / Linux
curl -X POST "$ANTHROPIC_BASE_URL/v1/messages" \
  -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "{\"model\":\"$ANTHROPIC_MODEL\",\"max_tokens\":1,\"messages\":[{\"role\":\"user\",\"content\":\".\"}]}"

# Windows PowerShell
Invoke-RestMethod -Method Post -Uri "$($env:ANTHROPIC_BASE_URL)/v1/messages" `
  -Headers @{ "Authorization" = "Bearer $env:ANTHROPIC_AUTH_TOKEN"; "anthropic-version" = "2023-06-01" } `
  -ContentType "application/json" `
  -Body (@{ model = $env:ANTHROPIC_MODEL; max_tokens = 1; messages = @(@{ role = "user"; content = "." }) } | ConvertTo-Json -Depth 4)

If the smoke returns JSON with msg_, the URL and key work. If it returns 401, the client sent the key with the wrong header; use ANTHROPIC_API_KEY only for an x-api-key scenario.

Images: in Claude Code attach a local file with the native command/button and select a vision-capable model. A separate provider flag is normally unnecessary, but an image + text smoke is required after changing the endpoint.

Codex CLI and the IDE extension can use ApiClo through a custom provider in config.toml.

1. 1

   In the Codex IDE extension, open Codex Settings → Open config.toml; the CLI uses the same ~/.codex/config.toml.

2. 2

   Add the provider to the user-level config because project .codex/config.toml should not define provider/auth.

3. 3

   Set APICLAUDE_API_KEY to your sk-hub key. This variable name is chosen by env_key below.

4. 4

   Keep wire_api = responses: in current Codex this is the supported provider protocol.

5. 5

   Run codex in a test folder and verify Reply only OK.

model = "claude-sonnet-5"
model_provider = "apiclaude"

[model_providers.apiclaude]
name = "ApiClo"
base_url = "https://apiclo.com/v1"
env_key = "APICLAUDE_API_KEY"
wire_api = "responses"

# macOS / Linux
export APICLAUDE_API_KEY="sk-hub-..."
codex

# Windows PowerShell
$env:APICLAUDE_API_KEY="sk-hub-..."
codex

If Codex rejects the provider config, update Codex first. Do not switch wire_api to Chat Completions: current Codex docs describe responses as the supported provider protocol.

Images: in the IDE extension attach the image through the composer; in CLI provide the local path using the native flow. Test an image + text request separately: provider configuration alone does not prove delivery of the attachment.

OpenClaw can be connected through models.json with two provider modes.

1. 1

   Install OpenClaw for your platform and check openclaw --version.

2. 2

   Find the OpenClaw models file or create models.json in the config folder.

3. 3

   For Claude Messages mode, use provider apiclaude-messages with baseUrl https://apiclo.com.

4. 4

   For OpenAI Completions mode, use provider apiclaude-openai with baseUrl https://apiclo.com/v1.

5. 5

   Add input: [text, image] to every vision model, otherwise OpenClaw passes only a text media reference or omits the image.

6. 6

   Replace apiKey with an sk-hub key and run separate text, tool, and image tests in a project.

{
  "models": {
    "mode": "merge",
    "providers": {
      "apiclaude-messages": {
        "baseUrl": "https://apiclo.com",
        "apiKey": "sk-hub-...",
        "auth": "token",
        "api": "anthropic-messages",
        "models": [
          {
            "id": "claude-sonnet-5",
            "name": "claude-sonnet-5",
            "input": ["text", "image"],
            "contextWindow": 1000000,
            "maxTokens": 64000
          }
        ]
      },
      "apiclaude-openai": {
        "baseUrl": "https://apiclo.com/v1",
        "apiKey": "sk-hub-...",
        "auth": "token",
        "api": "openai-completions",
        "models": [
          { "id": "claude-opus-4-8", "name": "claude-opus-4-8", "input": ["text", "image"] }
        ]
      }
    }
  }
}

If Qwen Code is installed as an OpenAI-compatible client, OPENAI_* variables are enough.

1. 1

   Check Node.js: node --version.

2. 2

   Install Qwen Code: npm install -g @qwen-code/qwen-code@latest.

3. 3

   Check qwen --version and qwen --help.

4. 4

   For OpenAI-compatible mode, set OPENAI_API_KEY, OPENAI_BASE_URL, and OPENAI_MODEL.

5. 5

   If your Qwen Code build supports Anthropic env, you can use ANTHROPIC_AUTH_TOKEN + https://apiclo.com for Claude models.

6. 6

   Use images only if the installed Qwen Code version exposes attachment/image input for a custom endpoint; otherwise the client may send text only.

7. 7

   Run qwen and perform the OK/read-only test.

export OPENAI_API_KEY="sk-hub-..."
export OPENAI_BASE_URL="https://apiclo.com/v1"
export OPENAI_MODEL="claude-sonnet-5"
qwen

$env:OPENAI_API_KEY="sk-hub-..."
$env:OPENAI_BASE_URL="https://apiclo.com/v1"
$env:OPENAI_MODEL="claude-sonnet-5"
qwen

Aider works through OpenAI-compatible variables.

1. 1

   Install Aider: python -m pip install -U aider-chat.

2. 2

   Open a terminal in a git project where test edits are safe.

3. 3

   Set OPENAI_API_BASE and OPENAI_API_KEY.

4. 4

   Run aider --model openai/claude-sonnet-5.

5. 5

   For an image, run /add image.png or /paste, then ask a text question; the selected model must support vision.

6. 6

   First ask it to explain a file; only allow edits after the connection is verified.

OMP connects through ~/.omp/agent/models.yml. Vision capability is declared with the model input field.

1. 1

   Install OMP with curl -fsSL https://omp.sh/install | sh; on Windows PowerShell use irm https://omp.sh/install.ps1 | iex.

2. 2

   Create ~/.omp/agent/models.yml and add the apiclo custom provider.

3. 3

   Set apiKey to the APICLO_API_KEY variable name instead of putting the secret in a repository.

4. 4

   Keep input: [text, image] on vision models: OMP checks this field before sending an attachment.

5. 5

   Run omp models find apiclo, then omp and test text, tools, and a separate image.

providers:
  apiclo:
    baseUrl: https://apiclo.com/v1
    api: openai-completions
    apiKey: APICLO_API_KEY
    models:
      - id: gpt-6-astra
        name: GPT 6 Astra
        input: [text, image]
        contextWindow: 200000
        maxTokens: 128000
      - id: claude-fable-5-1
        name: Claude Fable 5.1
        input: [text, image]
        contextWindow: 1000000
        maxTokens: 128000

Pi supports custom OpenAI-compatible models through models.json; declare image capability explicitly.

1. 1

   Install Pi using its official instructions and create ~/.pi/agent/models.json.

2. 2

   Set APICLO_API_KEY in the environment; do not store the key in a project file.

3. 3

   In /model, select apiclo/gpt-6-astra or apiclo/claude-fable-5-1.

4. 4

   Test a short text request, a tool call, and a separate image with a text question. Declaring input: image alone does not prove delivery.

{
  "providers": {
    "apiclo": {
      "baseUrl": "https://apiclo.com/v1",
      "api": "openai-completions",
      "apiKey": "$APICLO_API_KEY",
      "models": [
        { "id": "gpt-6-astra", "input": ["text", "image"], "contextWindow": 200000 },
        { "id": "claude-fable-5-1", "input": ["text", "image"], "contextWindow": 1000000 }
      ]
    }
  }
}

Kimi Code accepts a custom OpenAI-compatible provider; ApiClo compatibility is still undergoing our test matrix.

1. 1

   Install Kimi Code and open ~/.kimi-code/config.toml; preserve your existing settings.

2. 2

   Set APICLO_API_KEY in the environment and add an openai provider with a /v1 base URL.

3. 3

   Register the required model with image_in and tool_use, then select it in the client.

4. 4

   Test text, tools, reasoning, and images separately. Do not treat this integration as validated for autonomous tasks until the tests pass.

[providers.apiclo]
type = "openai"
base_url = "https://apiclo.com/v1"
api_key_env = "APICLO_API_KEY"

[models."apiclo/gpt-6-astra"]
provider = "apiclo"
model = "gpt-6-astra"
max_context_size = 200000
capabilities = ["image_in", "tool_use"]

Orca manages multiple CLI agents and isolated git worktrees. It does not replace the child agent's provider configuration.

1. 1

   First configure one working ApiClo executor: Codex, Claude Code, OpenCode, or OMP, including a separate vision test.

2. 2

   Install Orca Desktop/ADE from the official release for your OS and open the target git repository.

3. 3

   Add the already configured CLI as an agent runtime. The ApiClo key stays in the CLI's secure store or environment, not in Orca project files.

4. 4

   Use a separate worktree per agent for parallel work and cap the number of concurrent workers.

5. 5

   Send images to the specific child CLI session. Support is determined by that CLI's model capability: OpenCode modalities, Harness/OMP input, or Crush supports-images.

Crush supports OpenAI-compatible providers and a per-model supports-images flag.

1. 1

   Install current Crush and open the global crushrc at ~/.config/crush/crushrc or %USERPROFILE%\.config\crush\crushrc.

2. 2

   Add an apiclo provider of type openai-compat and disable automatic addition of unknown models.

3. 3

   Register each model with model add and set --supports-images true only for vision models.

4. 4

   Select the large model with model large and start Crush in a test project.

5. 5

   On Windows, include a text question with the image: some Crush versions reject an image-only prompt.

provider add apiclo \
  --name "ApiClo" \
  --type openai-compat \
  --base-url "https://apiclo.com/v1" \
  --api-key "$APICLO_API_KEY" \
  --discover-models false

model add apiclo/gpt-6-astra \
  --name "GPT 6 Astra" \
  --context-window 200000 \
  --default-max-tokens 128000 \
  --can-reason true \
  --supports-images true

model large apiclo/gpt-6-astra

Goose supports custom OpenAI-compatible providers in Desktop and CLI. Verify image capability in the installed version with a separate test.

1. 1

   Open Settings → Models → Configure providers → Add Custom Provider.

2. 2

   Provider Type: OpenAI Compatible; Display Name: ApiClo; API URL: https://apiclo.com/v1/chat/completions.

3. 3

   Enable Authentication, save the sk-hub key, and add gpt-6-astra and claude-fable-5-1.

4. 4

   Enable Streaming Support and verify a short text request.

5. 5

   The current Goose custom-provider screen has no universal per-model vision flag. If the attachment button is hidden or the file is removed before the request, use OpenCode, Harness, OMP, or Crush where the capability is explicit.

Gemini CLI is not a good direct ApiClo target right now unless your build lets you set a custom OpenAI/Anthropic endpoint.

1. 1

   First check whether your Gemini CLI version has a custom base URL setting.

2. 2

   If custom endpoint is unavailable, do not try to override Google system variables: use Cline, Roo, Kilo, or Qwen Code.

3. 3

   If a custom OpenAI-compatible endpoint is available, use Base URL https://apiclo.com/v1, sk-hub API key, and model claude-sonnet-5.

4. 4

   Verify images with a separate test: the custom endpoint must receive an image part, not only a local path. If that Gemini CLI version cannot do this, use OpenCode, Harness, OMP, or Crush.

5. 5

   After setup, run only a read-only test. If the client still calls the Google endpoint, switch to a supported CLI.

Built-in Hermes lives inside ApiClo: balance, model, memory, and history are managed from Agents.

1. 1

   Open Agents and choose Hermes.

2. 2

   Choose a model from the paid list: claude-sonnet-5, claude-opus-4-8, claude-sonnet-4-6.

3. 3

   For web pages, enable web context in chat; the URL will be read through the ApiClo reader/browser fallback.

4. 4

   For an image, use the composer attachment and a vision-capable model; after upload ask a text question to distinguish real image input from a filename.

5. 5

   To let Hermes work with your computer, download Desktop Bridge, create a pairing code, and grant only the needed file or folder permissions.

6. 6

   For long tasks, avoid switching models mid-chain without a reason; it helps cache and context.

The local router is useful when a client only talks to localhost or when you want to centralize the key on the machine.

1. 1

   Download ApiClo Desktop Bridge and run it on the same machine as the IDE/CLI.

2. 2

   Paste the upstream sk-hub key into Desktop Bridge.

3. 3

   Click Fetch models and make sure the model list loads.

4. 4

   Click Start router.

5. 5

   In the IDE/CLI, set Local Base URL http://127.0.0.1:18441/v1 and any non-empty client API key.

6. 6

   For images, enable the capability in the IDE/CLI itself: Desktop Router transparently forwards multipart/base64 image content but does not create an attachment button or declare vision for the client.

7. 7

   Test Reply only OK; if it does not answer, check that the local router is running and port 18441 is free.

Click Fetch models first, then Start router. In the IDE, use the local Base URL, not the public one.

Main route for IDEs, SDKs, and most self-hosted interfaces.

curl https://apiclo.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "messages": [{"role": "user", "content": "Hi"}],
    "max_tokens": 512,
    "stream": true
  }'

Use this for clients expecting Claude Messages API.

curl https://apiclo.com/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 512,
    "messages": [{"role": "user", "content": "Hi"}]
  }'

Use this for clients that need the Responses wire API.

curl https://apiclo.com/v1/responses \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "input": "Write a short checklist for release QA."
  }'

Good for scripts, backend jobs, and tests.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://apiclo.com/v1",
)

response = client.chat.completions.create(
    model="claude-sonnet-5",
    messages=[{"role": "user", "content": "Hi"}],
    max_tokens=512,
)

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

Good for frontend-backed API routes and Node.js services.

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.APICLAUDE_API_KEY,
  baseURL: "https://apiclo.com/v1",
});

const response = await client.chat.completions.create({
  model: "claude-sonnet-5",
  messages: [{ role: "user", content: "Hi" }],
  max_tokens: 512,
});

console.log(response.choices[0].message.content);