How to run Claude Code for free in 2026 using a local proxy, free provider tiers, and local models. Setup steps, routing strategy, and the real trade-offs.
Claude Code is the best AI coding agent on the market. It is also expensive — a serious week of vibe-coding on Opus 4.7 will burn through more than a month of a developer's coffee budget. For solo developers, students, side-projectors, and anyone working out of a cost-sensitive region, "use Claude Code daily" and "respect my budget" feel like they cannot both be true.
They can. There are real paths to running Claude Code at zero or near-zero cost in 2026 — paths that keep the CLI, the IDE extensions, the model picker, and the tool-use workflow intact. The cleanest one is a local proxy called Free Claude Code that routes your Claude Code requests to 17+ alternative model providers. Several of those providers have free tiers. Some of them run locally on your laptop. Combine the two, and Claude Code costs you nothing.
This guide walks through the whole thing — what counts as "free", the proxy setup, the providers worth routing to, per-model routing strategy, the limits and gotchas, and when the free path stops being worth it. By the end you will have a working free Claude Code stack that you can run today.
Let us be honest about the word first. There are four meaningful flavours of "free Claude Code", and they trade off differently.
| Flavour | What it means | Honest cost |
|---|---|---|
| 1. Anthropic's own free tier | Claude.ai web app, limited free usage | Free, but no Claude Code CLI or IDE integration |
| 2. Proxy to free provider tiers | Claude Code talking to NVIDIA NIM / OpenRouter / Gemini free | $0 — but you accept rate limits and non-Anthropic models |
| 3. Proxy to local models | Claude Code talking to Ollama / LM Studio / llama.cpp | $0 in API cost, but you need decent local hardware |
| 4. Hybrid free + paid routing | Free tier for routine work, small paid budget for hard tasks | $5-15/mo instead of $100+/mo |
This post is mostly about flavours 2, 3, and 4 — the ones that give you the full Claude Code experience (the CLI, the IDE plugin, the model picker, tool use, file editing) without the Anthropic API bill. Flavour 1 is great but it is just Claude.ai chat, which is a different product from the coding agent.
Pro tip: "Free Claude Code" in this guide does not mean a cracked or pirated Anthropic API. It means using the official Claude Code client — the legitimate CLI and IDE extensions — and pointing them at non-Anthropic model backends through an open-source proxy. Everything we describe is fully above-board and MIT-licensed.
Install Claude Code as normal. Install the Free Claude Code proxy alongside it. Point Claude Code at the proxy. Configure the proxy to route your requests to any combination of free providers and local models. Run.
The proxy is a 17-provider gateway that translates between Claude Code's expected Anthropic API shape and each backend provider's actual API. Claude Code never knows it is talking to anything other than Anthropic. The model picker, the streaming, the tool use, the reasoning blocks — all of it keeps working. Built and maintained under MIT license; the source is on GitHub.
Total time start to finish: about 15 minutes if you already have Claude Code installed.
If you are reading this post you probably already have it. If not:
npm install -g @anthropic-ai/claude-code
Or use the VS Code Claude Code extension, the JetBrains plugin, or whichever surface you prefer. All of them work with the proxy approach.
One command per OS.
macOS / Linux:
curl -fsSL "https://github.com/Alishahryar1/free-claude-code/blob/main/scripts/install.sh?raw=1" | sh
Windows PowerShell:
irm "https://github.com/Alishahryar1/free-claude-code/blob/main/scripts/install.ps1?raw=1" | iex
The installer pulls the proxy, installs Python 3.14 if you do not have it, and registers two binaries on your path: fcc-server (the proxy daemon) and fcc-claude (a wrapper that launches Claude Code pointing at the proxy).
fcc-server
The proxy starts listening on http://127.0.0.1:8082. You can leave this running in a background terminal tab, or run it as a launchd / systemd service if you want it always-on.
Open the local admin UI in your browser at http://127.0.0.1:8082/admin. This is where you tell the proxy which providers to use.
For each provider you want to use, you add an API key (or a local endpoint URL, in the case of Ollama / llama.cpp / LM Studio). The admin UI validates the key by making a test request and shows you green if it works.
For a true free setup, the providers worth adding first:
In the admin UI, the routing tab lets you decide which incoming Claude model name goes to which backend provider. The default Claude Code model names are claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5, plus the Fable 5 line.
A working free setup we recommend:
| Claude model tier | Free backend | Notes |
|---|---|---|
| Opus-class (hardest tasks) | DeepSeek V3 (via OpenRouter free) or Gemini 2.5 Pro (free tier) | Highest reasoning, slowest |
| Sonnet-class (default) | Gemini 3.5 Flash (via Google AI Studio free) | Fast, generous free quota |
| Haiku-class (routine) | Llama 3.3 70B (via Groq or Cerebras) | Instant responses, free |
| Fallback | Local Ollama or LM Studio | Never rate-limits, always available |
fcc-claude
The wrapper sets the right environment variables and starts Claude Code. The model picker now shows the models your proxy routes for. Tool use, streaming, file editing — all of it works exactly like vanilla Claude Code.
If you prefer the VS Code Claude Code extension, add these to settings.json under claudeCode.environmentVariables instead:
"ANTHROPIC_BASE_URL": "http://localhost:8082"
"ANTHROPIC_AUTH_TOKEN": "freecc"
"CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY": "1"
"CLAUDE_CODE_AUTO_COMPACT_WINDOW": "190000"
Then restart the extension. Done. JetBrains ACP follows the same env-variable pattern.
Not every free tier is equal. Two weeks of testing each one inside Claude Code with the proxy, the practical ranking:
Gemini 3.5 Flash via Google AI Studio is the best default. Generous daily quota (the free tier limit is high enough that most solo developers never hit it in a real day's work), 2M context window, native multimodal, and low latency. Quality is genuinely close to Sonnet-class on most coding tasks. Wire it up as your Sonnet-class default and your routine coding will not notice the difference.
NIM hosts a serious catalogue including DeepSeek, Llama 3.3, Qwen, and several proprietary models. Free tier is generous, latency is good, and the model catalogue is large enough to cover both routine work and hard reasoning. Wire it up as a secondary route for Opus-class work where Gemini falls short.
Both offer free tiers on open-weight Llama and Qwen models. Inference speed is the killer feature — both run at 500+ tokens/sec, which makes the Haiku-class tier feel instant inside Claude Code. Use them for routine refactors, quick lookups, and any task where the agent loop benefits from low latency.
OpenRouter exposes several free-tier models (DeepSeek V3, Llama, Mistral, occasionally Gemini Flash). Quality varies by model; the free tier rate limits are tighter than the individual provider tiers. Worth wiring up as a fallback chain rather than a primary route.
DeepSeek V3 has its own API with very low pricing (it is not free-free but it is cents-per-million-tokens cheap). Quality on coding tasks is genuinely competitive with Sonnet. If you are willing to spend $1-3 a month, wiring DeepSeek as the Opus-class route is a strong move.
The most underrated path. If you have a decent laptop or a desktop with a GPU, you can run Claude Code against entirely local models — no internet, no rate limits, no privacy concerns.
Easiest entry point. Install Ollama, pull a model:
ollama pull qwen3-coder:30b
ollama pull llama3.3:70b
Then in the Free Claude Code admin UI, add Ollama as a provider pointing at http://localhost:11434. Route your Haiku-class and fallback traffic to it. On a 32GB M-series Mac or a 24GB GPU, the 30B Qwen3-coder model delivers genuinely usable coding output at ~30 tokens/sec.
If you prefer a GUI for downloading and managing models, LM Studio is the same idea with a nicer interface. Models you pull through it expose an OpenAI-compatible API the proxy can call.
For maximum control. Compile from source, pick your quantisation, run with whatever flags you want. Best for users who already live in the local-model world.
The local-models path has one big upside (zero cost, zero rate limits, full privacy) and one tradeoff (you need hardware, and quality is below the frontier closed models). For a hybrid setup — frontier free tiers for hard tasks, local models as a no-limit fallback — it is genuinely hard to beat.
If you route every Claude Code request to the same backend, the free path eventually breaks. Either you hit a rate limit, or you get the cheap-model-on-a-hard-task problem where the agent loops and burns tokens trying to recover.
Per-model routing fixes this. You assign different backends to different Claude model tiers, and Claude Code's model picker becomes a real lever: pick Opus when you want the hard reasoning, Haiku when you want speed, Sonnet for the middle ground. Each routes to the best free provider for that workload.
A working routing config:
The proxy handles the fallback chain automatically — if Gemini hits its quota, the next request transparently goes to Groq, then to Cerebras, then to your local Ollama. Claude Code never sees a failure; you just keep coding.
Pro tip: Set up the fallback chain even if you do not think you will hit limits. The single most annoying experience is being mid-flow on a coding task and getting a rate-limit error from your primary provider. With fallbacks, the proxy handles it silently.
The free path is real, but it is not magic. The trade-offs you accept:
None of these are deal-breakers for the target audience (cost-sensitive developers, students, hobbyists, side-projectors). For a senior engineer at a funded company shipping production code, the trade-offs are usually not worth it — pay for the real thing.
Free Claude Code ships with optional wrappers that turn the proxy into a remote coding agent.
None of these are required. All of them are useful enough that we have personally kept the Telegram bot running ever since we set it up. Voice-driven Claude Code is genuinely a different way to use the tool.
The free path makes sense for a real majority of Claude Code users. Where it stops:
The clean split: hobby code, learning, side projects, exploratory work → free path. Production work, billable client work, time-sensitive output → paid path. Most developers do both kinds of work and should run both stacks.
You can run Claude Code for free in 2026, fully and legitimately. The path is a local proxy (Free Claude Code) routing your requests to free provider tiers and optional local models. The CLI, the IDE plugins, the model picker, the tool use, the file editing — everything works. You give up some quality on the hardest tasks and you accept rate limits, but for the majority of coding work the experience is genuinely good.
If you build software for a living and have a real budget, pay for Claude Code. If you are a student, a hobbyist, a side-projector, or anyone building in a cost-sensitive context, the free path is real and it works today. 15 minutes of setup, and you have a Claude Code stack that costs you nothing.
10 questions answered
Free AI Image Generation in the Terminal: ChatGPT Plus + Gemini Guide
Jun 12 · 12 min
How to Create a UI Design Skill Using design.md
Jun 12 · 19 min
AI Skills vs Prompts: What's the Difference?
Jun 11 · 18 min
HeyGen Hyperframes Prompts for Editing Videos: 40+ Working Examples
Jun 11 · 18 min
Claude Fable 5 Prompts for Web Developers: UI, Code Review, Debugging
Jun 11 · 18 min