Skip to main content
One Capriole AI API key can authenticate Codex, Claude Code, Kilo Code, GitHub Copilot CLI, OpenCode, OpenClaw, Cline, Qwen Code, Crush, and Pi. The key stays the same, while the base URL, protocol, and model selector must match the client you are configuring. Use this guide to move from one Capriole account to a working agent. Personal Premium costs USD 9 per month, includes 5 million charged API tokens, and also unlocks unlimited browser chat across the supported Premium model set. One membership can therefore cover the browser workspace and all 10 maintained agent paths. The individual integration pages remain the source of truth for complete client configuration.

Before you start

You need:
  • active Capriole AI Premium or eligible Team access;
  • a Capriole AI API key from the API page;
  • at least one installed coding agent;
  • a terminal where you can set an environment variable.
Keep the API key out of repositories and committed configuration files. The examples use YOUR_CAPRIOLE_AI_API_KEY as a placeholder.
This guide reuses one key to prove compatibility. For a long-lived setup or a team, create a separate named key for each agent or user. Separate keys reduce the impact of a leaked credential and let you filter usage or revoke access independently from the API page.

Match the agent to its protocol

Each client keeps the wire protocol it was built to use, even though the account key is shared. Responses and Chat Completions paths include /v1 in the base URL. Anthropic Messages paths use the API root, except where an integration page documents a client-specific adapter value. Copy the exact value from the matching integration page.

Set up the shared key

1

Export the Capriole API key

Set one shell variable before opening an agent:
Verify that the variable exists without printing the secret:
The expected result is Capriole API key is set.
2

Choose the client path

Open the integration page from the table and copy its maintained configuration. Use the same value from CAPRIOLE_AI_API_KEY wherever that client asks for a token.
  • Codex reads the key from CAPRIOLE_AI_API_KEY through env_key.
  • Claude Code uses ANTHROPIC_AUTH_TOKEN. Set it from the shared variable before launch.
  • Kilo Code references {env:CAPRIOLE_AI_API_KEY} in apiKey and in an Authorization header. Its one Capriole provider sends each model family to Responses, Messages, or Chat Completions.
  • GitHub Copilot CLI uses COPILOT_PROVIDER_API_KEY on OpenAI-compatible paths and COPILOT_PROVIDER_BEARER_TOKEN on Anthropic Messages.
  • OpenCode references {env:CAPRIOLE_AI_API_KEY} in apiKey and in an Authorization header. Its one Capriole provider sends each model family to Responses, Messages, or Chat Completions.
  • OpenClaw provider entries reference ${CAPRIOLE_AI_API_KEY} directly. Export the shared variable in the terminal that starts the gateway.
  • Cline saves the key once with cline auth -k "$CAPRIOLE_AI_API_KEY".
  • Qwen Code names the variable in envKey and can read it from ~/.qwen/.env.
  • Crush reads $CAPRIOLE_AI_API_KEY in its crushrc provider entry.
  • Pi reads $CAPRIOLE_AI_API_KEY in models.json.
For Claude Code:
3

Keep the model on a compatible route

Start with a maintained alias unless you need an exact model version:
  • use openai-latest on OpenAI Responses paths, or the native gpt-6.2-astra in Codex;
  • use claude-latest on Anthropic Messages paths, or claude-fable-5-1 in Claude Code;
  • use a model listed by the integration page on Chat Completions-compatible paths.
The current model catalog lists public API models.
4

Launch and verify the agent

Start the configured client from a test project and ask:
Look for a non-empty answer, ideally the requested CAPRIOLE_OK marker. Models do not always follow exact-output prompts, so the wording may differ.Then open the API page and confirm that the request appears in the usage view under the expected key and model. The usage record is the decisive check that the client used Capriole. A response alone is not enough when the client has another provider or fallback configured. The API keys and usage guide shows the exact filters and key lifecycle.

What success looks like

Coding-agent requests use the eligible personal or Team API balance. Read Capriole AI charged tokens before running a large automated workload.

Fix common setup failures

Choose the next page

Read the coding-agent compatibility article when you need the model behind these routes. For direct application code, continue with the OpenAI and Anthropic SDK guide. LLM gateway security risks lists what to check before an agent sends your source code. If your agent is not one of these 10, connect it through a custom endpoint. Try the current flagship models in free browser chat, then upgrade to Premium when you are ready to create the API key used by your coding agents.
Last modified on November 18, 2026