“Run Free Unlimited Claude Code” — And None Of The Sixteen Serves Claude

The card is a six-step build sheet, and it is a good one. “Run free Unlimited Claude Code. 16 free LLM APIs, no credit card on any of them, routed into one Claude Code setup.” Step 1, collect keys from Gemini, Mistral, Cohere, Z AI and Aion Labs. Step 2, add the high-limit hosts: Groq at 30 requests a minute, NVIDIA NIM at 40, SiliconFlow at 1,000. Step 3, the model hubs. Step 4, the keyless fallbacks. Step 5, point a router at all sixteen. Step 6, read the fine print.

The caption goes further: “You can run Claude Code for $0 now (almost unlimited). Someone on GitHub built a router that gives you 7.4 billion free tokens every month across 635 models.”

The router is real. We found it, read its code listing, its star count and its own disclaimer. The sixteen providers are real. The free tiers are real. Almost everything on this card checks out.

What does not check out is the three words in the middle of the headline.

Not one of the sixteen serves Claude

Go through the card’s own list. Gemini, Mistral, Cohere, Z AI, Aion Labs, Groq, NVIDIA NIM, SiliconFlow, OpenRouter, Hugging Face, Workers AI, Ollama, Kilo Code, LLM7, OVHcloud, ModelScope. Sixteen names, and Anthropic is not one of them.

We checked the router’s own repository to be sure. Its published provider grid reads Google, Groq, Cerebras, OpenCode Zen, Mistral, OpenRouter, Cloudflare, Cohere, Z.ai, NVIDIA, HuggingFace, ModelScope, “and 22 more free providers”. Anthropic appears exactly twice in the whole document: once as a client you can point at the router, and once in this line:

“Anthropic Messages API — /v1/messages speaks Anthropic’s wire format over the same router, so Claude Code and the official Anthropic SDKs run against your free pool.”

Read that twice. The router speaks Anthropic’s wire format. A wire format is the shape of the plug, not the thing at the other end of the cable. Claude Code sends a request that looks exactly like a request to Anthropic, and something that is not Anthropic answers it.

Nor could it be otherwise. Anthropic’s pricing page lists every Claude model with a per-token price and no free tier at all. There is no free Claude API for a router to pool. That is not a gap in the card’s research; it is the reason the card exists.

So the honest title is not “run free unlimited Claude Code.” It is run Claude Code free, without Claude.

Diagram: the harness stays, the engine leaves

That distinction is not pedantry, because Claude Code is two things bolted together and the router only replaces one of them.

The practical consequence is simple and nobody says it on a card: Claude Code’s behaviour was tuned around Claude. Its system prompt, its tool descriptions, its habit of reading three files before editing one — all of that is calibrated for a model that follows long instructions and calls tools accurately over many turns. Hand that same harness to a free 8-billion-parameter model and you have not got a cheaper Claude Code. You have got a very different agent wearing its clothes.

Some of the free models are genuinely strong, and on a small, well-scoped task you may not notice. On a forty-turn refactor you will notice in the first ten minutes.

The repository is more honest than the card

The router on the card is FreeLLMAPI, and it is not a toy. At the time of writing it carries 33,462 stars and 4,614 forks, it is MIT-licensed, written in TypeScript, and was last pushed to the day before we wrote this. Its own description is where the caption’s numbers come from, word for word:

“7.4 billion tokens per month. 34 free LLM providers. 635 free model endpoints. All behind one /v1 endpoint… Personal experimentation only.”

Those last two words did not make it onto the card, and they are the author’s own. The repository’s disclaimer section spells it out further:

“This project is for personal experimentation and learning, not production. Free tiers exist so developers can prototype against them; they aren’t a stable, supported inference substrate and shouldn’t be treated as one. If you build something real on top of FreeLLMAPI, swap in a paid API before you ship. Your relationship with each upstream provider is governed by the terms you accepted when you created your account — those terms still apply when the traffic is proxied through this project, and you’re responsible for complying with them.”

That is a model of how to publish something like this. The person who built the router says plainly: prototype, do not ship, and the provider terms follow your traffic through the proxy. The card that promotes it says “almost unlimited”.

Two more details from the repository that change the picture slightly, and neither is a criticism of the project:

• There is a paid tier. The project sells a premium router at $19 a year. Free installs still work; they receive the model catalogue on a monthly snapshot, so a newly free model reaches them about thirty days after it reaches paying users.
• The numbers belong to 34 providers, not 16. The caption quotes 7.4 billion tokens and 635 endpoints — the repository’s figures for its full list. The card curates sixteen of them. Both are fine; they are just not the same number.

Why “7.4 billion tokens” is not a budget

It is a sum, and the things it sums do not add up in the way the sentence implies. A monthly allowance at Groq cannot be spent at Mistral. A thousand requests a minute at SiliconFlow does nothing for you when the model you need is only on Cohere, whose trial key is capped at roughly a thousand calls a month in total.

It is sixteen gift cards from sixteen different shops, totalled up and called cash. The router’s failover is exactly the right engineering answer to that — when one card is empty, reach for the next — but it means the model you get is whichever one is not currently rate-limited, not the one you chose. Every response carries an X-Routed-Via header precisely because you cannot otherwise know who answered.

One more thing worth noticing in the card’s sixteen: Ollama is not a free API. It is a local runtime. Its tokens are free in the sense that your own electricity and your own GPU are free. Workers AI is Cloudflare, which is also where the card’s step 3 hub lives. Counting both is not wrong, it just makes sixteen look wider than it is.

All six steps, checked

The card is accurate far more often than not. Here is each step against what we could verify.

Step 6 stops one step too early

Credit where it is due: the card has a fine-print step at all, with a red cross next to “client secrets in prompts.” That puts it ahead of most of what circulates.

But look at what Google’s Gemini API terms actually say about the unpaid tier:

“Google uses the content you submit to the Services and any generated responses to provide, improve, and develop” its products — and “human reviewers may read, annotate, and process your API input and output.” The terms then instruct, in their own words: “Do not submit sensitive, confidential, or personal information to the Unpaid Services.”

Now put that next to what Claude Code is. It is not a chat box. It is an agent that reads your files. It opens source files, configuration, logs, test fixtures and whatever else it needs, and it sends their contents as part of the request. You never typed them, so “don’t put secrets in your prompts” does not protect you. The agent assembles the prompt.

So the accurate version of step 6 is not “avoid client secrets in prompts.” It is: every file this agent reads goes to an unpaid endpoint whose terms tell you not to send confidential material, and a human may read it. For a personal toy repository that is a perfectly reasonable trade. For a client codebase under an NDA it is not a trade you are allowed to make.

Two fair qualifications. Google’s terms say the data is disconnected from your account, API key and Cloud project before a reviewer sees it. And in the EEA, Switzerland and the UK, the paid-service data terms apply to free services too — so readers there are in a different position from everyone else. On Cohere, the card is right: trial keys are rate-limited and intended for prototyping rather than commercial use, with the trial capped around a thousand calls a month.

The comparison the card does not make

If the goal is “$0”, the card wins by definition. But almost nobody’s real goal is zero; it is small. And the moment you allow a few pence into the picture, the shape of the decision changes, because the cheapest genuine Claude is cheaper than most people assume.

For a hobby project, a hundred thousand input tokens is a cent. That is the number the “$0 vs paid” framing hides: for the kind of work the router is honestly recommended for — learning, side projects — real Claude costs small change, and you skip sixteen signups, a proxy and a terms-of-service problem.

Which does not make the card wrong. It makes it a card about something else: a free pool of open models with a Claude-shaped socket on the front. That is a genuinely useful thing to own, and there are good reasons to want it — running offline against Ollama, trying twenty open models without twenty integrations, working somewhere a card payment is hard. Just not under the name on the headline.

Four honest caveats

1. We did not install the router. Everything above comes from the project’s public repository, its own documentation, and the providers’ published terms and prices. We cannot tell you how well its failover works in practice, and star counts measure attention, not quality — a lesson we learned the hard way last time we checked a set of them.
2. Free tiers move weekly. Rate limits, model availability and keyless endpoints change faster than any card or article can track. The card’s own footer says it: check each provider before you rely on it. That applies to our figures too, read in October 2026.
3. “Free models are worse” is not a claim we are making. Several of the open models reachable this way are strong, and on a contained task you may see no difference at all. The claim is narrower: they are not Claude, and the harness was built around Claude.
4. Nothing here is against the card’s author. Step 6 exists, the footer tells you to verify, and the project is named rather than hidden behind a comment-for-the-link. Our objection is to three words in a headline, not to the work underneath it.

The one-line version

You can absolutely run the Claude Code CLI against sixteen free APIs for nothing, and someone has built a good router for it. What you cannot do is run Claude that way, because no free Claude API exists for a router to pool. You keep the harness and lose the engine — which is a reasonable trade for learning, the exact trade the project itself recommends, and not the trade the word “unlimited” describes.

If you want the longer version of why a free swap is rarely like-for-like, we wrote it up as the free pick is real, it is just not always the same thing, and the budget version is the $0 stack and the free-tier treadmill.