> ## Documentation Index
> Fetch the complete documentation index at: https://docs.crazyrouter.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Claude Code Setup Guide

> Connect Claude Code to Crazyrouter through the Anthropic Messages API, with full step-by-step instructions from Git and Node.js to installation commands, environment variables, and first-run validation

> Last updated: 2026-06-06

Claude Code is one of the best terminal coding tools to connect to Crazyrouter. It speaks the Anthropic Messages API directly and works especially well for code reading, editing, refactoring, command execution, tool use, and long-context repository analysis.

## Overview

With a few environment variables, Claude Code can send Anthropic requests directly to Crazyrouter:

* recommended protocol: `Anthropic Messages API`
* base URL: `https://api.crazyrouter.com`
* default international API base URL: `https://api.crazyrouter.com`
* auth variable: `ANTHROPIC_API_KEY`
* recommended default model: `claude-opus-4-8`

<Tip>
  Claude Code appends the Anthropic request path itself, so the base URL must stay at the site root: `https://api.crazyrouter.com`. Do not append `/v1` or `/v1/messages`.
</Tip>

<Card title="View the Claude Code one-click setup repository" icon="github" href="https://github.com/xujfcn/crazyrouter-claude-code">
  If you want a script to install Claude Code and write the Crazyrouter environment variables for you, review the crazyrouter-claude-code repository.
</Card>

## Best For

* developers who want Crazyrouter as the backend for Claude Code
* users who want stable tool use, long context, and terminal-first coding workflows
* teams that want Claude Code billed separately from Cursor, Codex, or Aider
* cross-platform setups that need one consistent CLI configuration

## Protocol Used

Recommended protocol: `Anthropic Messages API`

Use:

```text theme={null}
ANTHROPIC_BASE_URL=https://api.crazyrouter.com
```

For the default international API entry, use:

```text theme={null}
ANTHROPIC_BASE_URL=https://api.crazyrouter.com
```

Do not use:

* `https://api.crazyrouter.com/v1`
* `https://api.crazyrouter.com/v1/messages`
* `https://api.crazyrouter.com/v1/complete`
* `https://api.crazyrouter.com/v1`
* `https://api.crazyrouter.com/v1/messages`

## System Requirements And Prerequisites

| Item                | Notes                                                              |
| ------------------- | ------------------------------------------------------------------ |
| Crazyrouter account | Create one at [crazyrouter.com](https://crazyrouter.com)           |
| Crazyrouter token   | Create a dedicated `sk-...` token for Claude Code                  |
| Git                 | `git 2.23+` is recommended for reviewing and rolling back AI edits |
| Node.js             | `Node.js 18+` is recommended                                       |
| Claude Code         | Use a current stable release                                       |
| Claude model access | Allow at least `claude-opus-4-8` on the token                      |

Suggested starter allowlist:

* `claude-opus-4-8`
* `claude-opus-4-8`

## Full Install Paths By OS

### Recommended Windows path

On Windows, the safest path is: `Git` + `Node.js` + `npm global install for Claude Code` + `PowerShell` for environment variables.

Recommended order:

1. Install Git
2. Install Node.js LTS
3. Install Claude Code with npm
4. Set temporary variables in PowerShell
5. Persist user-level variables in PowerShell

Recommended verification:

```powershell theme={null}
git --version
node -v
npm -v
claude --version
where.exe git
where.exe node
where.exe claude
```

If `claude --version` is still not found, close and reopen PowerShell before retrying.

### Recommended macOS path

On macOS, the smoothest path is usually: `Xcode Command Line Tools` + `Homebrew` + `Git` + `Node.js` + `npm global install for Claude Code` + `~/.zshrc` for persistent environment variables.

Recommended order:

1. Install Xcode Command Line Tools
2. Install Homebrew if needed
3. Install Git and Node.js
4. Install Claude Code with npm
5. Persist variables in `~/.zshrc`
6. Open a fresh terminal and verify the binary path

Recommended verification:

```bash theme={null}
git --version
node -v
npm -v
claude --version
which git
which node
which claude
```

### Why you should not append API paths manually

Claude Code uses the Anthropic-native protocol. You only provide the site root:

```text theme={null}
ANTHROPIC_BASE_URL=https://api.crazyrouter.com
```

The default international API entry also uses only the site root:

```text theme={null}
ANTHROPIC_BASE_URL=https://api.crazyrouter.com
```

Do not append `/v1`, `/v1/messages`, or any specific API path the way you would with an OpenAI-compatible client.

If you prefer a script that installs Claude Code and writes the Crazyrouter-related environment variables automatically, see [crazyrouter-claude-code](https://github.com/xujfcn/crazyrouter-claude-code). That repository provides one-click setup scripts for Windows, macOS, and Linux; this guide keeps the full manual path so you can audit each setting.

## Full Setup From Scratch

<Steps>
  <Step title="Step 1: Install Git">
    If Git is not installed yet, install it first before touching Claude Code.

    <Tabs>
      <Tab title="Windows PowerShell">
        ```powershell theme={null}
        winget install --id Git.Git -e --source winget
        git --version
        ```
      </Tab>

      <Tab title="macOS">
        ```bash theme={null}
        xcode-select --install
        git --version
        ```

        If you already use Homebrew, you can also run:

        ```bash theme={null}
        brew install git
        git --version
        ```
      </Tab>

      <Tab title="Ubuntu / Debian">
        ```bash theme={null}
        sudo apt update
        sudo apt install -y git
        git --version
        ```
      </Tab>
    </Tabs>

    After installation, set your global identity once:

    ```bash theme={null}
    git config --global user.name "Your Name"
    git config --global user.email "you@example.com"
    git config --global init.defaultBranch main
    ```
  </Step>

  <Step title="Step 2: Install Node.js 18+">
    Claude Code depends on Node.js. Verify the installed version before going further.

    <Tabs>
      <Tab title="Windows PowerShell">
        ```powershell theme={null}
        winget install OpenJS.NodeJS.LTS
        node -v
        npm -v
        ```
      </Tab>

      <Tab title="macOS">
        ```bash theme={null}
        brew install node
        node -v
        npm -v
        ```
      </Tab>

      <Tab title="Ubuntu / Debian">
        ```bash theme={null}
        sudo apt update
        sudo apt install -y nodejs npm
        node -v
        npm -v
        ```
      </Tab>
    </Tabs>

    If `node -v` is still below 18 after installation, upgrade through `nvm` or the official Node installer before continuing.
  </Step>

  <Step title="Step 3: Install Claude Code">
    <Tabs>
      <Tab title="Windows PowerShell">
        ```powershell theme={null}
        npm install -g @anthropic-ai/claude-code
        claude --version
        where.exe claude
        ```
      </Tab>

      <Tab title="macOS">
        ```bash theme={null}
        npm install -g @anthropic-ai/claude-code
        claude --version
        which claude
        ```
      </Tab>
    </Tabs>

    <Warning>
      Do not use `sudo npm install -g @anthropic-ai/claude-code`. If global npm permissions are broken, fix the npm/Node environment first instead of forcing a privileged install.
    </Warning>
  </Step>

  <Step title="Step 4: Create a dedicated Crazyrouter token for Claude Code">
    Log in to Crazyrouter and create a separate token named something obvious like `claude-code`.

    For the first pass, allow only:

    * `claude-opus-4-8`
    * `claude-opus-4-8`

    Give it its own budget so it does not share spend with Cursor, Codex, or OpenClaw.
  </Step>

  <Step title="Step 5: Set temporary environment variables in the current terminal">
    Start with a temporary setup first. Once validation succeeds, make it persistent.

    <Tabs>
      <Tab title="macOS / Linux">
        ```bash theme={null}
        export ANTHROPIC_BASE_URL=https://api.crazyrouter.com
        export ANTHROPIC_API_KEY=sk-xxx
        echo $ANTHROPIC_BASE_URL
        echo $ANTHROPIC_API_KEY
        ```
      </Tab>

      <Tab title="Windows PowerShell">
        ```powershell theme={null}
        $env:ANTHROPIC_BASE_URL = "https://api.crazyrouter.com"
        $env:ANTHROPIC_API_KEY = "sk-xxx"
        echo $env:ANTHROPIC_BASE_URL
        echo $env:ANTHROPIC_API_KEY
        ```
      </Tab>
    </Tabs>

    Set `ANTHROPIC_BASE_URL` to the root domain `https://api.crazyrouter.com`, not `https://api.crazyrouter.com/v1`.
  </Step>

  <Step title="Step 6: Persist the environment variables">
    Temporary variables disappear after the shell closes. For regular use, write them to your shell profile.

    <Tabs>
      <Tab title="Linux Bash">
        ```bash theme={null}
        echo 'export ANTHROPIC_BASE_URL=https://api.crazyrouter.com' >> ~/.bashrc
        echo 'export ANTHROPIC_API_KEY=sk-xxx' >> ~/.bashrc
        source ~/.bashrc
        ```
      </Tab>

      <Tab title="macOS / Zsh">
        ```bash theme={null}
        echo 'export ANTHROPIC_BASE_URL=https://api.crazyrouter.com' >> ~/.zshrc
        echo 'export ANTHROPIC_API_KEY=sk-xxx' >> ~/.zshrc
        source ~/.zshrc
        ```
      </Tab>

      <Tab title="Windows PowerShell">
        ```powershell theme={null}
        [System.Environment]::SetEnvironmentVariable("ANTHROPIC_BASE_URL", "https://api.crazyrouter.com", "User")
        [System.Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "sk-xxx", "User")

        $env:ANTHROPIC_BASE_URL = "https://api.crazyrouter.com"
        $env:ANTHROPIC_API_KEY = "sk-xxx"
        ```
      </Tab>
    </Tabs>

    Persist `ANTHROPIC_BASE_URL` as `https://api.crazyrouter.com`.

    Then open a fresh terminal and re-check:

    <Tabs>
      <Tab title="macOS / Linux">
        ```bash theme={null}
        claude --version
        echo $ANTHROPIC_BASE_URL
        ```
      </Tab>

      <Tab title="Windows PowerShell">
        ```powershell theme={null}
        claude --version
        echo $env:ANTHROPIC_BASE_URL
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Step 7: Prepare your Git repository">
    Claude Code can edit files and run commands. For the first validation, use a repo you know well.

    If the current folder is not a Git repo yet:

    ```bash theme={null}
    git init
    git add .
    git commit -m "chore: initial snapshot before Claude Code"
    ```

    If it is already an existing repo, at least confirm the current state first:

    ```bash theme={null}
    git status
    ```
  </Step>

  <Step title="Step 8: Launch Claude Code and complete the first validation">
    Enter the project directory and run:

    ```bash theme={null}
    cd /path/to/your/project
    claude
    ```

    For the first validation, use this order:

    1. `Reply with only OK`
    2. `Read the current repository structure only. Do not modify any files.`
    3. `Find obvious typos in the README, but do not edit files yet.`

    If all three work and Crazyrouter logs show matching requests, the setup is good.
  </Step>
</Steps>

## Recommended Model Setup

| Use case                        | Recommended model | Why                                                            |
| ------------------------------- | ----------------- | -------------------------------------------------------------- |
| default daily driver            | `claude-opus-4-8` | best balance of quality, speed, and cost for most coding tasks |
| difficult refactors             | `claude-opus-4-8` | stronger complex reasoning, planning, and code understanding   |
| long-context repo analysis      | `claude-opus-4-8` | stable and strong for long sessions                            |
| cost-sensitive first validation | `claude-opus-4-8` | first get the main path working reliably                       |

Recommended rollout: stabilize normal work on `claude-opus-4-8`, then switch to `claude-opus-4-8` only for genuinely heavier tasks.

## Using Non-Claude Models in Claude Code

Beyond the native Claude family, Crazyrouter exposes several third-party models through the Anthropic Messages protocol. You can use them in Claude Code simply by switching the model name. The list below has been **end-to-end verified** (text / system / tool use / streaming SSE all pass).

### Verified working models

| Model ID                                        | Provider      | Tool Use | Streaming | Thinking   | Best For                                    |
| ----------------------------------------------- | ------------- | -------- | --------- | ---------- | ------------------------------------------- |
| `deepseek-v4-pro`                               | DeepSeek      | ✅        | ✅         | —          | General coding & refactors, best price/perf |
| `deepseek-v4-flash`                             | DeepSeek      | ✅        | ✅         | ✅ native   | Reasoning with visible thinking blocks      |
| `deepseek-v4-pro`                               | DeepSeek      | Yes      | Yes       | reasoning  | General text and reasoning tasks            |
| `MiniMax-M2.7`                                  | MiniMax       | Yes      | Yes       | plain text | Long-context and Chinese-heavy tasks        |
| `kimi-k2.5` / `kimi-k2.6`                       | Moonshot Kimi | Yes      | Yes       | plain text | Long-context and Chinese-heavy work         |
| `kimi-k2-thinking`                              | Moonshot Kimi | ✅        | ✅         | reasoning  | Complex reasoning                           |
| `kimi-k2-0711-preview` / `kimi-k2-0905-preview` | Moonshot Kimi | ✅        | ✅         | —          | Snapshot versions                           |

> Tested against `https://api.crazyrouter.com/v1/messages` with `anthropic-version: 2023-06-01` using a standard Anthropic Messages payload.

<Warning>
  The following models currently return `get_channel_failed` on the Anthropic protocol (an upstream channel availability issue, not a protocol incompatibility). Use them via `/v1/chat/completions` (OpenAI protocol) for now:

  * `moonshot-v1-8k` / `moonshot-v1-32k` / `moonshot-v1-128k`
  * `kimi-k2-0905` (without the `-preview` suffix)

  Channels such as `grok-*`, `coze`, `jimeng`, `baidu`, `zhipu`, `tencent`, `xunfei`, `mistral`, `cohere`, and `palm` **do not implement** Anthropic protocol conversion and cannot be used in Claude Code.
</Warning>

### How to switch models

Claude Code picks the model from the `ANTHROPIC_MODEL` environment variable, or via the in-session `/model` command. Replace the value with any model ID from the table above.

<Tabs>
  <Tab title="macOS / Linux">
    ```bash theme={null}
    export ANTHROPIC_BASE_URL=https://api.crazyrouter.com
    export ANTHROPIC_API_KEY=sk-xxx

    # Default to DeepSeek V4 Pro
    export ANTHROPIC_MODEL=deepseek-v4-pro
    claude

    # Or one-off switch to Kimi thinking
    ANTHROPIC_MODEL=kimi-k2-thinking claude

    # Or one-off switch to MiniMax
    ANTHROPIC_MODEL=MiniMax-M2.7 claude
    ```
  </Tab>

  <Tab title="Windows PowerShell">
    ```powershell theme={null}
    $env:ANTHROPIC_BASE_URL = "https://api.crazyrouter.com"
    $env:ANTHROPIC_API_KEY  = "sk-xxx"

    $env:ANTHROPIC_MODEL = "deepseek-v4-pro"
    claude

    # Or one-off switches
    $env:ANTHROPIC_MODEL = "kimi-k2-thinking"; claude
    $env:ANTHROPIC_MODEL = "MiniMax-M2.7"; claude
    ```
  </Tab>
</Tabs>

You can also switch inside a running Claude Code session:

```text theme={null}
/model deepseek-v4-pro
/model kimi-k2-thinking
/model MiniMax-M2.7
```

### Usage notes and known differences

* **DeepSeek family**: highest protocol fidelity. Tool calls, streaming, and `stop_reason=tool_use` all match Anthropic's spec; `deepseek-v4-flash` returns native `thinking` blocks that Claude Code renders as a thinking pane. **Recommended default: `deepseek-v4-pro`**.
* **Kimi family**: strong long-context behavior, tool calls work normally. `kimi-k2-thinking` includes a reasoning trace, useful for hard tasks.
* **MiniMax family**: use the current public `MiniMax-M2.7` ID for new examples. If an older MiniMax snapshot is still allowed on your token, verify it through `/v1/models` before putting it in a Claude Code profile.
* **Token allowlist**: if your Claude Code-dedicated token has model allowlisting enabled, add the models above to it in the Crazyrouter dashboard, otherwise you will get `403 model not allowed`.
* **Thinking and billing**: thinking-enabled models (`-thinking`, `-flash`, `reasoner`, `MiniMax-M2.7`) consume extra output tokens. Set a separate budget cap on the Claude Code token.

### One-line check that a model works

```bash theme={null}
curl -sS https://api.crazyrouter.com/v1/messages \
  -H "Authorization: Bearer $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "max_tokens": 32,
    "messages": [{"role":"user","content":"reply OK"}]
  }'
```

A `200` response with non-empty `content[].text` means Claude Code can use this model.

## Token Setup Best Practices

| Setting                | Recommendation                           | Notes                                                                                     |
| ---------------------- | ---------------------------------------- | ----------------------------------------------------------------------------------------- |
| dedicated token        | Required                                 | Do not share Claude Code tokens with Cursor, Codex, or OpenClaw                           |
| model allowlist        | Strongly recommended                     | Most Claude Code setups only need 1 to 2 Claude models                                    |
| IP restriction         | Recommended on fixed-egress environments | Be careful on laptops with changing IPs                                                   |
| quota cap              | Strongly recommended                     | Long sessions and tool use can steadily consume budget                                    |
| developer / host split | Recommended                              | Give each developer or shared host its own token                                          |
| incident rotation      | Required                                 | If shell history, recordings, or shared terminals expose the token, rotate it immediately |

## Verification Checklist

* [ ] `git --version` works
* [ ] `node -v` is at least 18
* [ ] `claude --version` works
* [ ] `ANTHROPIC_BASE_URL` is set to `https://api.crazyrouter.com`
* [ ] `ANTHROPIC_API_KEY` is set correctly
* [ ] Claude Code launches successfully
* [ ] the first plain-text request succeeds
* [ ] repository read-only inspection works
* [ ] Crazyrouter logs show the Claude Code traffic
* [ ] token quota and model allowlist match your intended setup

## Common Errors And Fixes

| Symptom                                                                     | Likely cause                                                                                                | Fix                                                               |
| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| `claude: command not found`                                                 | Claude Code did not install cleanly, or the npm global path is not on PATH                                  | reinstall and make sure the global npm bin directory is in PATH   |
| Node version is too old                                                     | local Node.js version is below the requirement                                                              | upgrade to Node.js 18+ and reinstall Claude Code                  |
| `401 unauthorized`                                                          | invalid, expired, or badly pasted `ANTHROPIC_API_KEY`                                                       | create a new token and set the variables again                    |
| `403` or `model not allowed`                                                | the token does not allow the selected Claude model                                                          | allow the required model in Crazyrouter                           |
| `404`                                                                       | base URL was set with `/v1` or `/v1/messages`                                                               | reset it to `https://api.crazyrouter.com`                         |
| logs show `/v1/v1/messages`, `/v1/v1/models`, or `/v1/messages/v1/messages` | Claude Code was given a base URL that already contains `/v1` or a full endpoint, then appended its own path | set `ANTHROPIC_BASE_URL` to the root domain with no path          |
| Claude Code still uses old settings                                         | new environment variables were not reloaded                                                                 | reopen the terminal or run `source ~/.bashrc` / `source ~/.zshrc` |
| Git changes become messy                                                    | no repository snapshot was created before AI edits                                                          | commit an initial snapshot before larger changes                  |
| cost is higher than expected                                                | long context, repeated tool use, and long sessions                                                          | shorten sessions, split tasks, and cap budget per token           |

## Performance And Cost Tips

* start with `claude-opus-4-8`
* switch to `claude-opus-4-8` only for hard architecture analysis or heavy refactors
* validate first in a small repo, not a large production repo
* check `git status` before each new task
* watch Crazyrouter logs and quota more closely when tool use becomes frequent

## FAQ

### Which base URL should I use for Claude Code?

Use the site root: `https://api.crazyrouter.com`

For the default international API entry, use the site root: `https://api.crazyrouter.com`

### Why should I not include `/v1` here?

Because Claude Code appends the Anthropic Messages path itself. You only provide the site root.

### What should I use on Windows?

If you mainly develop from the command line, prefer PowerShell or WSL2. In either case, make sure Git, Node.js, and Claude Code itself are installed correctly first.

### On Windows, should I use PowerShell or Git Bash?

For first-time setup, prefer PowerShell. Environment-variable persistence, `where.exe` checks, and user-level configuration are all more direct there.

### Why should I create a Git snapshot before the first real task?

Because Claude Code can edit files and run commands. A clean snapshot makes review and rollback much easier.

### Which model should I try first?

Start with `claude-opus-4-8`. It is usually the safest baseline.

<Note>
  If your first priority is Claude-family models plus a terminal-first coding workflow, Claude Code should be near the front of your Crazyrouter integration order.
</Note>

<Card title="View the crazyrouter-claude-code repository" icon="github" href="https://github.com/xujfcn/crazyrouter-claude-code">
  Review the one-click setup scripts, README, and latest usage notes.
</Card>