Claude Code Router: Route Claude Code to Any Model

Claude Code Router (CCR) is a small local proxy that intercepts Claude Code's Anthropic-formatted API calls and forwards them to any model you want — DeepSeek, Qwen, GLM, Kimi, Mistral, Ollama, or a gateway. The pitch is cost: cheap models run 20-50x below Claude Sonnet per token. The open question everyone hedges on is quality. So we ran a real generate-code-then-run-hidden-tests benchmark across 13 models — and 10 of 13, including the two cheapest at about $0.10-0.13 per 1,000 tasks, scored a perfect 9/9. This guide explains how CCR works, how to set it up, and exactly which cheap models are safe to route to.

What Claude Code Router is

Claude Code Router (CCR) is an open-source, MIT-licensed local proxy that lets Claude Code run against non-Anthropic models. The canonical project is musistudio/claude-code-router, which had roughly 25k+ GitHub stars as of mid-2026 — up from about 26k in early 2026, a sign of fast-rising adoption. It sits between Claude Code and Anthropic, catches the requests Claude Code would send to the API, and redirects them to a provider of your choice: DeepSeek, Qwen, GLM/Z.AI, Kimi/Moonshot, Mistral, OpenRouter, or a local Ollama model.

The reason people reach for it is almost always cost. Claude Code is excellent, but its default models are premium-priced, and an agent that reads files, plans, edits and re-runs tests burns tokens fast. If most of that work can be done by a model that costs a fraction as much, the savings compound. The catch — the thing every existing write-up hedges on — is whether the cheaper model is good enough. We put a hard number on that below.

How it works: proxy, transformers, routing

The mechanism is simple and clever. Claude Code decides which API to call from the ANTHROPIC_BASE_URL environment variable. CCR starts a local endpoint, sets ANTHROPIC_BASE_URL to that address plus a dummy ANTHROPIC_API_KEY, and spawns Claude Code pointed at it. Claude Code sends its normal Anthropic-formatted requests believing it is talking to Anthropic — but they land on the local proxy instead.

From there, two things happen:

• A transformers pipeline translates formats. CCR ships 20+ built-in transformers (DeepSeek, Gemini, OpenRouter, Groq, Vertex AI, and more) that convert between Claude Code's Anthropic Messages format and each provider's API — adjusting max-token limits, optimizing tool-use payloads, and extracting reasoning content so the response comes back in the shape Claude Code expects.
• A router picks the model per scenario. The config.json Router block assigns a model to each request type: default (general coding), background (cheap, fast throwaway tasks), think (reasoning and planning), longContext (past a threshold, default around 60,000 tokens), webSearch, and image (beta). You can also switch on the fly inside a session with /model.

Supported providers include any OpenAI-compatible API, Anthropic Messages, Gemini, OpenRouter, DeepSeek, SiliconFlow, Moonshot/Kimi, Mistral, Z.AI (GLM), Bailian/Qwen, Ollama for local models, and custom endpoints. That OpenAI-compatible support is the seam we exploit in the gateway section below. If translating request formats between provider APIs sounds familiar, it is the same problem an OpenAI-compatible API layer solves at the server side.

Setup: CLI vs desktop

CCR comes in two forms, and it matters which one you are following in a tutorial because the endpoints differ.

Both do the same core thing — stand up a local endpoint and set ANTHROPIC_BASE_URL to it. The CLI is not obsolete; the desktop app is a friendlier front end for the same idea. If you want the fastest path, install the CLI, drop your provider keys into config.json, set your Router.default model, and run ccr code exactly where you would normally run claude. For a fuller walkthrough of Claude Code itself, see our guide to using Claude Code, and for the GLM path specifically, Claude Code with GLM 5.

Do cheap models hold up? Our benchmark

Here is the part no one else brings data to. The common advice — route simple tasks to a free or cheap model, keep the flagship for hard stuff — is usually asserted, not measured. So we ran a first-party executed benchmark in July 2026: 13 models, 9 tasks, each task a generate-code-then-run-hidden-tests problem. The model writes code; we run its output against tests it never saw. No vibes, no leaderboard scrape.

The headline: 10 of 13 models scored a perfect 9/9 — and the cost for identical quality spanned 88x.

The two cheapest models in the field were also the two cheapest to run and still perfect: Qwen3 Coder Next at $0.10 per 1,000 tasks (9/9, 0 reasoning tokens) and DeepSeek V4-Flash at $0.13 (9/9). At the other end, GPT-5.5 also scored 9/9 — for $8.83, 88x more. Claude Opus 4.8 was 9/9 at $4.05. A second finding worth routing on: Mistral Medium 3.5, a non-reasoning dense model, was the fastest in the whole test at 2.9s per task — non-reasoning models generally beat the heavy reasoners on both latency and cost per task.

What this means for CCR: the exact work a router pushes off Anthropic — routine, well-specified coding tasks — is precisely where cheap models converge on flagship quality. You are not trading quality for price on that tier; you are just paying less. Full results and methodology are in our best cheap LLM for coding writeup and the linked benchmark page.

Point it at one gateway

CCR's power is also its friction: to route across many providers you configure a separate API key, base URL, and transformer for each one. That is a lot of moving parts to keep current. Because CCR speaks to any OpenAI-compatible endpoint, there is a cleaner arrangement — point the router at a single LLM gateway and let the gateway fan out to the underlying models.

DataLLM Lab is exactly that: one OpenAI-compatible endpoint fronting 300+ models on one key. In CCR you register it as a single provider and then select DeepSeek, Qwen, GLM 5.2, Mistral, Claude or GPT by model name with /model — the gateway handles the provider-specific routing. That collapses per-provider key management into one credential and makes the cheap-first-with-escalation pattern trivial to express: cheap model as default and background, a stronger model on think and longContext. For the broader cost strategy behind this, see cutting token costs on coding agents.

Where cheap models fall short

To keep this honest: the benchmark proves cheap models are viable on standard tasks, not that they are equal everywhere. Three documented trade-offs matter when you route.

• Weak tool-calling stalls agent loops. Cheaper and open models often have weaker tool-calling than Claude. In agentic use that shows up as malformed edits, models that narrate what they would do instead of emitting a tool call, empty responses, or loops that stall. This is model-specific and improving fast — but check tool-calling behavior before trusting a model with an autonomous loop.
• Complex multi-file work degrades. Quality holds on well-scoped tasks and drops on complex, multi-file architecture work. Even in our own benchmark, a few models missed one task each (DeepSeek V4-Pro on CSV parsing, Grok 4.3 on nested-dict flattening, StepFun 3.7 Flash on valid-parentheses) — small cracks that widen on harder, longer work.
• Realistic savings are ~3-5x, not 10x. On a real mixed workflow — where some fraction of tasks genuinely need a stronger model — blended savings land closer to 3-5x rather than the per-token 20-50x you see on the cheapest tasks. And extended-thinking behavior may be lost when you route away from a model that supports it.

The practical takeaway is the routing pattern CCR is built for: default to a cheap model, escalate the hard cases. The benchmark tells you the cheap tier is safe on the majority; the caveats tell you to keep an escalation path for the minority.

FAQ