Free Claude Code: a $0 setup and five ways it breaks

Free Claude Code (FCC) can connect the Claude Code client to other providers’ free inference endpoints. You keep the familiar read → edit → run tools → inspect loop, while another model generates the next step. The proprietary Claude model is not included in that offer. FCC is an independent community project, and every selected endpoint still has its own eligibility, limits and terms. [1]

This guide targets roughly ten minutes of configuration after your provider accounts and phone verification are ready. Downloads, regional checks and troubleshooting can take longer. We checked FCC v6.16.16 source and the provider documentation on October 23, 2026. We validated the acceptance-test fixture locally; we did not complete NVIDIA registration or run provider-backed inference, so this is a source-checked setup guide rather than a timed hands-on benchmark.

Direct Claude usage can be included within a subscription allowance or charged through an API account. In API usage, input, output and caching affect the bill; a long coding session repeatedly sends context, tool results and follow-up requests. One user prompt can trigger several model calls. A monthly plan and a per-token API invoice are different payment mechanisms. [2]

FCC changes the inference route. Claude Code still manages the local conversation and tools; the replacement model chooses actions within that workflow. FCC translates requests and responses, maps model tiers and can try fallback models. It does not upgrade the client’s orchestration algorithm, and a replacement model’s tool use or reasoning may differ from Claude’s. The launcher sets ANTHROPIC_BASE_URL to FCC and removes inherited ANTHROPIC_* environment variables for the child process. Use fcc-claude for this route, rather than assuming an ordinary claude session follows it. [1]

Start with macOS/Linux and a terminal. Windows PowerShell commands are also shown. The installer manages FCC’s Python/uv requirements and offers coding-agent installation; choose Claude Code, and leave optional voice, messaging and output-compression integrations off for this first run. Those extras are not required for NVIDIA or OpenRouter. Download and inspect the script before running it. This snapshot pins both the installer source and FCC package version. [1]

Windows PowerShell:

After installation, reopen the terminal if fcc-server is missing from PATH. Start the server explicitly in a terminal and keep it open. Avoid opening the desktop launcher first: the guide needs control over the bind address. The version commands should identify your installed FCC and Claude Code versions.

The reviewed FCC defaults are HOST=0.0.0.0 and PORT=8082, with proxy authentication disabled. The HOST override below keeps this session on loopback. In Windows use the second block. Open the Admin URL printed in the server log; port 8082 is the default, not an instruction to ignore your actual log. [10]

Windows PowerShell:

A successful health response confirms that the local process is reachable. It does not prove that an API key, model or free tier works.

Open NVIDIA’s API-key page, register or sign in, and complete the verification it requests. Generate your own key, then open FCC Admin → Providers → NVIDIA NIM → Add key. Paste it, Save, select a model in MODEL, and Apply. The README’s current example is nvidia_nim/nvidia/nemotron-3-ultra-550b-a55b; check that its model page still offers a free hosted endpoint and supports the tools you need. NVIDIA hardware is not required for its hosted API. [1][3]

“Verification from the CIS” has no single reliable procedure. Eligibility and SMS options depend on country and account. NVIDIA’s forum contains a Russia +7 missing-country report and a request for manual verification; that post does not establish an approved workaround or guaranteed support approval. If your country or number is unsupported, stop this branch, contact official support, or use a provider available to you. Borrowed keys and rented verification numbers are poor foundations for an account you need to control. [5]

A NVIDIA moderator confirms a published personal free-tier ceiling of 40 requests per minute. Treat it as a request-rate ceiling, subject to endpoint conditions and throttling, not a token allowance or guaranteed throughput. Parallel agents can exhaust it in bursts. Honor 429 responses and retry delays; adding more keys is not a sound capacity plan. [4]

Create an OpenRouter key at https://openrouter.ai/keys. In FCC Admin → Providers → OpenRouter, add the key and Save. Select open_router/openrouter/free in MODEL and Apply for a simple trial. That router selects from compatible free models, so the underlying model can change. For repeatable coding tasks, choose a currently listed, tool-capable :free model and keep its exact identifier. Appending :free to an arbitrary paid model does not create a free endpoint. [1][7][8]

First verify NVIDIA and OpenRouter separately as the primary model. Then make NVIDIA primary and add the tested free OpenRouter route to the ordered Fallback Models list under Model Config. Inspect the per-tier settings too: Fable, Opus, Sonnet and Haiku should inherit the intended model or explicitly use verified free routes. Every primary, tier override and fallback belongs in this audit. A paid fallback can create real charges; OpenRouter explicitly documents that behavior. [1][8]

For the strict $0 path, do not top up credits or add a paid route. OpenRouter’s published base free-model limits are 20 requests per minute and 50 per day across the account. The documented 1,000/day tier requires a lifetime credit purchase threshold of $10; it is not a zero-cash onboarding route. Check the account’s actual remaining allowance before starting a long task. [6][13]

Use an empty disposable directory, Node.js (the fixture was validated on v24.9.0), and the downloadable acceptance file below. On Windows, create the folder and download that file through PowerShell or the browser, then run fcc-claude inside it. Keep Claude Code’s normal tool approvals; this task does not need permission bypass flags. [12]

Give the agent this bounded task:

Run node --test acceptance.test.mjs yourself afterward. The unchanged fixture contains eight tests: a 697-cent basket, empty input, zero quantity, invalid values and overflow. Inspect the resulting files. Passing this small example checks basic tool use; it does not demonstrate production-level coding quality. PAS7’s reference implementation passed all eight locally without contacting a model.

For routing evidence, match that run’s time with FCC’s provider/model trace and the selected provider’s activity or usage view where available. Test each provider once before relying on automatic fallback. A connection error points to the server; 401 suggests authentication; 429 suggests capacity; an unavailable model requires a current catalog entry. A 402 should stop a $0 experiment for a billing/routing check rather than trigger an automatic top-up.

A client-side Sonnet label can describe the requested model tier or compatibility alias. FCC maps such requests to configured provider/model targets, and current versions also support gateway model discovery. If your build shows “Sonnet 5”, that label alone proves neither that Anthropic served the request nor that the replacement model has Sonnet’s capabilities. Asking the model its own name is equally weak evidence. Check the resolved route. [1]

The same distinction applies to money. Claude Code’s current documentation says /usage computes session dollars locally from token counts and list prices unless a pricing override applies; older versions expose /cost. A client estimate can therefore rise while a selected provider’s free endpoint incurs no inference charge. The provider’s usage ledger and configured route determine the billing conclusion. Do not dismiss an actual debit, a paid fallback or a separate direct-Claude session as a harmless display bug. [2][8]

FCC advertises 1.3B+ free tokens across its provider offering. The reviewed README does not provide an auditable personal monthly allowance for the NVIDIA-plus-OpenRouter pair. Keep the published units attached to each limit. [1][4][6][13]

Our planning example: 50 requests/day ÷ 10 model calls/task = five tasks/day before any other calls or retries. Over 30 days, 50 × 30 × an assumed 4,000 counted tokens/request = 6 million tokens. Both the ten-call task and 4,000-token average are assumptions, not measured workloads or provider promises. Repeated context can dominate token counts; those tokens are not all newly generated code.

A requests-per-minute ceiling cannot establish monthly tokens without request sizes, daily limits, latency, availability and sustained use. The useful saving is completing a bounded task for no inference charge within a provider’s allowance. Count accepted changes and review time alongside token volume.

The replacement model may pick broader edits, mishandle tool arguments or need more repair turns. Start with small changes and fixed acceptance criteria. Compare the diff and test result on the same task before moving an entire project. A lower price per call can still produce a longer, less useful session.

Require the actual tool output and exit status, then rerun the test yourself. Check package names and API versions against their documentation. A plausible “all tests passed” paragraph is cheap to generate; it cannot replace a command trace. Our fixture keeps the tests outside the agent’s editing scope for that reason.

A free endpoint may disappear, lower its limits or stop accepting your region. NVIDIA’s terms reserve service changes; OpenRouter warns that free variants can have different availability. Keep a separately tested free fallback and allow the task to stop when none is available. Do not silently replace an unavailable :free ID with its paid counterpart. [8][11]

A client update can change request formats, model discovery or tool behavior; FCC and providers also change. Record both versions after a successful smoke test and rerun it after updating either side. The reviewed FCC launcher disables Claude’s automatic updater for its child process, so check explicitly for supported updates rather than leaving the stack frozen indefinitely. Save configuration before changing versions and keep the last working pair documented. [1]

Code fragments and tool results sent to a hosted model leave your machine. OpenRouter documents provider-specific training and logging policies, including separate controls for free models. Keep secrets and customer data out of the trial project, review provider data settings, bind FCC to loopback and enable Proxy Authentication with a unique token if access is shared. The reviewed default bind/auth settings make this worth checking explicitly. Never expose the Admin interface through a public tunnel just to finish a ten-minute setup. [9][10]

A usable setup has a recorded client/proxy version pair, two individually checked free routes, a clean test result and a visible stopping point when capacity runs out. Start with a small repository change whose result you can judge. That gives the $0 experiment a useful outcome even when the headline token count never materializes.