TL;DR: Free Claude Code (FCC) is a 62.5K-star AGPL proxy that points the official Claude Code CLI — plus Codex, Cline, Aider, and 7 other harnesses — at 61 model providers, including free-tier endpoints and local Ollama. It genuinely runs agentic coding sessions for $0, but the free path serves you Nemotron and other open-weight models, not Claude. Anthropic’s $20/month Pro plan remains the floor for actual Claude models in Claude Code.

	Free Claude Code (FCC)	Claude Pro + Claude Code	Claude Code + API billing
Best for	Budget-capped devs, provider hoppers, local-model users	Daily agentic coding with frontier Claude models	Spiky heavy usage, teams metering per-token
Price / Cost	$0 software + provider free tiers (or your own keys)	$20/mo ($17/mo billed annually)	Pay-as-you-go per token via Console
The catch	Free tiers serve open-weight models with fair-use caps, not Claude; you manage keys and churn	Usage pool shared with your Claude chats	Costs are unbounded; you watch a meter

Honest take: If “Claude Code for free” means “the Claude Code workflow for free,” FCC delivers and is the most complete router of its kind. If it means “Claude models for free,” it doesn’t exist — pay the $20 or run a local model honestly. FCC’s real value is as a 61-provider switchboard, not a discount.

“Free Claude Code” has been climbing GitHub’s trending charts all month, and the name does a lot of work. It suggests someone cracked Anthropic’s subscription. What the project actually is turns out to be more interesting and less scandalous: a local routing proxy, written in Python, that sits between a coding agent you already have and any of 61 model providers — several of which hand out free inference, most of which take your paid API key, three of which run on your own hardware.

We cloned the source on October 22, 2026 and read it rather than paraphrasing the README. Here is what FCC is, what the $0 claim holds up to, and who comes out ahead using it versus just paying Anthropic.

What Free Claude Code actually is (and isn’t)

FCC — repo Alishahryar1/free-claude-code, 62.5K stars and 9.8K forks as of October 22, 2026 — is not a fork of Claude Code and not a cracked client. It’s a man-in-the-middle you install on purpose: a local server that speaks the Anthropic Messages API on one side and 61 different provider APIs on the other. You launch the official Claude Code CLI through FCC’s fcc-claude wrapper, and every request Claude Code makes gets translated and routed to whatever model you’ve configured — NVIDIA’s hosted endpoints, OpenRouter, Groq, DeepSeek, a GitHub Copilot subscription you already pay for, or an Ollama model on your own GPU.

The project is explicit that it’s an independent effort: the README carries an “Independent open-source project. Not affiliated with or endorsed by Anthropic” disclaimer, and the license is AGPL-3.0-only, © 2026 Ali Khokhar.

It’s also broader than the name admits. The current release wraps 11 coding agents, not just Claude Code. From the shipped CLI commands: fcc-claude, fcc-codex, fcc-opencode, fcc-cline, fcc-aider, fcc-pi, fcc-hermes, fcc-dsh (DeepSeek Harness), fcc-grok (Grok Build), fcc-muse (Meta Muse Code), plus a VS Code Chat integration. One model catalog, one config, eleven harnesses. That’s the actual product; “Free Claude Code” is the marketing.

What we verified from the source

Star counts and README promises are cheap, so we pulled the repo apart. Commands we actually ran against the October 22 clone, with their output:

$ git ls-remote --tags https://github.com/Alishahryar1/free-claude-code | tail -1
refs/tags/v6.16.16

$ git log -1 --format='%h %ad %s' --date=iso
3d2ae23 2026-10-21 02:33:44 -0700 patch: Migrate retired NVIDIA Super selections to Ultra (#2135)

Latest release v6.16.16, last commit the day before this review, 1,200+ commits on main. This is an actively maintained project, not a stars-and-abandon repo — the most recent patch exists because NVIDIA retired a hosted model and FCC had to migrate defaults, which tells you something about the maintenance treadmill this architecture signs up for.

Counting the provider catalog directly in src/free_claude_code/config/provider_catalog.py confirms the README’s “61 providers” claim exactly: 61 catalog entries, from anthropic and openai through nvidia_nim, open_router, groq, cerebras, deepseek, github_copilot, down to the three local backends ollama, lmstudio, and llamacpp.

Two more things from the source worth knowing before you install:

• The default model is not Claude. constants.py sets DEFAULT_MODEL = "nvidia_nim/nvidia/nemotron-3-ultra-550b-a55b" — NVIDIA’s hosted Nemotron 3 Ultra. Out of the box, your “Claude Code” session is a Nemotron session wearing Claude Code’s interface.
• The runtime is pinned hard. pyproject.toml demands exactly Python 3.14.7 (requires-python = "==3.14.7") and the installer bootstraps everything through uv, pulling the uv installer from astral.sh and an RTK token-compression release from GitHub. The one-line install is doing real work on your machine; read scripts/install.sh before piping it to sh, the same advice we’d give for any installer — including Anthropic’s own.

Setup: what the $0 path looks like

Per the README at v6.16.16 (we inspected the installer rather than executing it in this review environment):

# macOS / Linux
curl -fsSL "https://raw.githubusercontent.com/Alishahryar1/free-claude-code/main/scripts/install.sh" | sh

# start the router, then launch a harness through it
fcc-server
fcc-claude

Compare the official route, which is one line and no proxy: curl -fsSL https://claude.ai/install.sh | bash, then claude in your project — but requires a paid Claude plan or Console API key the moment you want to do anything.

For most providers FCC needs an API key, even when the tier is free (NVIDIA’s endpoints require a Developer Program key, for example). Two exceptions do OAuth sign-in — an existing ChatGPT subscription and GitHub Copilot — which is FCC’s sneaky-good feature: if your employer already pays for Copilot, FCC lets Claude Code’s workflow bill against that seat. Local backends (Ollama, LM Studio, llama.cpp) just take a base URL: ollama pull llama3.1, ollama serve, point FCC at it, done.

Model IDs are provider-prefixed (nvidia_nim/..., ollama/..., open_router/...), and FCC can route Claude Code’s internal model tiers — the requests Claude Code makes for its Fable/Opus/Sonnet/Haiku slots — to different backends per tier. That’s a genuinely clever design: send the heavy “Opus-slot” planning calls to your best free endpoint and the “Haiku-slot” background calls to a local model.

The “1.3B+ free tokens” claim, audited

The README’s headline is “61 ToS-friendly providers. 1.3B+ free tokens every month.” Where would those tokens come from? Not from FCC — it operates zero inference. The number is an aggregate of third-party free tiers: NVIDIA’s free Developer Program endpoints, OpenRouter’s $0-priced models, Groq and Cerebras free allowances, Cloudflare Workers AI, and similar.

Three honesty flags on that number:

1. It’s the project’s own estimate, and the README undercuts it itself: “Free-tier availability and limits are controlled by each provider and may change.” We tried to pin down NVIDIA’s current free-tier limits from official pages and couldn’t complete verification this session (NVIDIA’s developer pages were unreachable from our environment); community guides disagree with each other on credit amounts and describe the tier as fair-use capped at tens of requests per minute. Treat every free lane as usable-but-capped and subject to revocation, not as a quota you can plan a job around.
2. Fallback chains can double-bill your quotas. FCC retries failed requests against the next configured model, and the README warns a single failed request may consume usage from more than one provider. On metered free tiers, an outage at provider A spends provider B’s allowance too.
3. “ToS friendly” is a claim, not a guarantee. The project says it follows provider terms and removes integrations that stop being allowed — the GitHub Copilot and ChatGPT OAuth lanes are the ones we’d watch, since routing third-party harnesses through subscription endpoints is exactly the pattern providers periodically crack down on. FCC notes some plans (Kimi Code, QwenCloud Coding) are restricted to personal interactive use. Your account, your risk.

The actual cost math

Verified against claude.com/pricing on October 22, 2026:

Path	Monthly cost	What model answers you	Agentic quality
FCC + provider free tiers	$0	Nemotron 3 Ultra (default), other open-weight models	Good, below frontier; rate-capped
FCC + Ollama local	$0 + hardware + power	Whatever fits your VRAM	Bounded by your GPU
FCC + your paid API keys	Per-token (you pick the provider)	Anything, incl. Claude via Anthropic key	Frontier, metered
Claude Pro	$20/mo ($17/mo annual)	Claude frontier models	Frontier; usage pool shared with chats
Claude Max	From $100/mo (5x–20x Pro)	Claude frontier models	Frontier, heavy usage

The thing the table makes obvious: FCC and Anthropic’s subscription aren’t actually competing on the same axis. The $0 FCC path trades model quality and rate ceilings for price. The moment you want Claude-class output through FCC, you’re back to paying someone — either an Anthropic API key (metered, often worse value than the flat $20 for daily use) or a subscription FCC piggybacks on. We ran this same break-even logic in the AI code editor cost comparison and it holds here: flat-rate subscriptions win for daily drivers, $0 open-weight routes win for budget-capped or privacy-capped use, and per-token loses for everyone except spiky workloads.

One scenario where FCC is simply correct: you already decided against a subscription. Compared to wiring Cline to a local model or configuring OpenCode by hand, FCC gives you the same $0 stack with less per-tool plumbing and a fallback chain when your local box is busy. And with Aider stalled (five months of silence), fcc-aider is also one of the easier ways to keep an Aider workflow alive against current model endpoints.

Where it breaks

The problem we kept circling in the source is churn exposure. FCC’s entire value is the catalog, and the catalog is 61 third-party dependencies that each change pricing, limits, and model lineups on their own schedule. The latest commit at review time was literally a forced migration off retired NVIDIA models. The project handles this actively — that’s the good news — but you inherit the treadmill: fcc-update is part of the workflow, not an occasional chore, and a free lane you built your day around can be gone next month.

Second, the Python 3.14.7 hard pin plus uv bootstrap makes the install heavier and more invasive than a typical CLI tool. It works, but it’s a full managed Python toolchain on your machine for what is conceptually a request translator.

Third, AGPL-3.0 deserves a sentence of precision, because “can I use this commercially?” is the top question under every FCC thread. Using FCC as a tool at work is fine — AGPL obligations trigger when you modify FCC and offer it to others over a network, not when you run it to write your own proprietary code. Companies that ban AGPL software outright will still ban it; that’s a policy problem, not a legal one.

Finally, the quality gap. There’s no public SWE-bench run of “Claude Code + FCC + Nemotron” versus native Claude Code, and we won’t invent one. What’s structurally true: Claude Code’s agentic loop, prompts, and tool definitions are tuned against Claude models, and open-weight backends routinely fall back to degraded edit formats and higher retry rates in harnesses built for frontier models — the same pattern we documented when pointing Claude Code at Ollama. Expect the free lane to feel like a competent mid-tier agent, not like Fable 5.

Who should use what

• You code daily and bill clients or ship a product: pay the $20. Claude Pro with Claude Code is the cheapest frontier agentic setup going, and your time recovers the fee in a morning. The full Claude Code review covers what you get.
• You’re a student, hobbyist, or between free credits: FCC is the best-organized $0 stack we’ve reviewed — better documented and more actively maintained than assembling OpenRouter configs per tool. Set realistic expectations for the default models.
• Your code can’t leave the building: FCC + Ollama is a legitimate pattern, but so is skipping FCC and configuring your harness against Ollama directly. FCC earns its place when you want several harnesses sharing one local backend config.
• Your employer pays for Copilot or ChatGPT and you want Claude Code’s workflow: FCC’s OAuth lanes do exactly this. Check your org’s tooling policy first; this is the lane most likely to run afoul of a provider’s terms interpretation someday.
• You want “free Claude”: it doesn’t exist here or anywhere. FCC gives you free Claude Code-shaped workflows; the models answering are not Claude.

FAQ

Is Free Claude Code safe to install? It’s AGPL open source with 1,200+ commits and an inspectable installer — audit-friendly, which beats most “free AI” offerings. It is still a proxy that sees every prompt and file your agent sends, so the trust question is “do I trust this codebase,” not “do I trust a vendor.” Read the installer; pin a commit if you’re cautious.

Does it work with the official Claude Code CLI or replace it? It wraps the official CLI. fcc-claude launches Claude Code configured to talk through FCC’s local server instead of directly to Anthropic.

Can FCC get my accounts banned? The project positions itself as ToS-friendly and drops integrations that stop being allowed, but routing subscription products (Copilot, ChatGPT) through third-party harnesses lives in terms-of-service gray space that providers re-interpret without notice. Free API-key tiers (NVIDIA, OpenRouter $0 models) are the lower-risk lanes.

Is the 1.3B free tokens per month real? It’s an aggregate of third-party free tiers that FCC doesn’t control, and the README itself says limits can change. Real enough to code on; not something to build a business on.

FCC with free models vs. just buying Claude Pro — which is better? For output quality per hour of your attention, Pro at $20/month wins and it isn’t close. For $0, FCC beats hand-rolling per-tool configs. The wrong answer is paying per-token for casual daily use — we did that math in the post-free-period cost breakdown.

Sources

• Free Claude Code — GitHub repository (Alishahryar1/free-claude-code)
• Free Claude Code release tags (v6.16.16 latest at review time)
• Free Claude Code LICENSE — AGPL-3.0-only
• Free Claude Code install script (inspected, not just piped)
• Claude plans and pricing — Anthropic official
• Claude Code overview and install — Anthropic official docs

Last verified October 22, 2026. Provider free tiers, catalog contents, and Claude plan pricing all change frequently — check the official pages before committing to a stack. Hardware for the local-backend path: see runaihome.com’s GPU buying guide for local AI; for the FOSS harness landscape, aifoss.dev’s Continue vs Cline vs Aider comparison.

Know which coding tool is worth paying for

Hands-on comparisons of AI coding assistants and what each one costs to run — including the local-model path. Sent only when something changes. Unsubscribe anytime.

Email address Subscribe