Gratis Claude Code Proxy: NVIDIA, OpenRouter en Ollama getest

Gratis Claude Code Proxy: NVIDIA, OpenRouter en Ollama getest

Ik heb afgelopen weekend een app voor het bijhouden van gewoontes gebouwd met de naam Habitual. Drie iteraties, twee herontwerpen, een echte database, werkende streaks-logica. Het hele ding – van begin tot eind – kostte me minder dan de prijs van een stuk kauwgom.

Als ik het had gebouwd zoals ik normaal doe, met mijn Claude Max-abonnement waarbij Opus 4.7 het zware werk doet, zou hetzelfde project ergens tussen de vijf en tien dollar aan API-tegoed hebben opgegeten bovenop mijn maandelijkse abonnement van $ 200. Geen fortuin. Maar voor een bijproject dat ik volgende week misschien schrap, zijn het precies de kosten die me twee keer doen nadenken voordat ik de terminal om middernacht opendoe.

Dit is wat er is veranderd. Ik heb Claude Code – de CLI, de agent, de uitvoering van het gereedschap, alles – precies hetzelfde gehouden. Ik ben niet overgestapt naar een andere IDE. Ik heb geen nieuwe workflow geleerd. Ik heb er gewoon een kleine open-source proxy onder geschoven, en die proxy heeft stilletjes elke API-oproep omgeleid naar een gratis of bijna gratis model op een andere infrastructuur. NVIDIA NIM. OpenRouter. Ollama draait op mijn MacBook. Drie backends, één proxy, dezelfde Claude Code-interface die ik al koud ken.

Het resultaat is niet perfect. Ik ga in op de plek waar het scheurt. Maar voor prototyping, leren, nevenprojecten en de lange staart van "Ik wil iets proberen, maar wil niet aan de kosten denken" - dit komt het dichtst in de buurt van een cheatcode die ik in 2026 heb gevonden.

Waarom ik hier überhaupt naar op zoek ging

Mijn Claude Max-abonnement kost $ 200/month.. Ik klaag niet: ik besteed het elke week aan klantwerk en ik zou het dubbele betalen voor de betrouwbaarheid. Volgens de [huidige prijsverdeling] van Anthropic (https://support.claude.com/en/articles/11049741-what-is-the-max-plan), levert Max 20x me ongeveer 20x het gebruiksvenster van het Pro-niveau op, wat neerkomt op ongeveer 220.000 tokens elke vijf uur op het API-equivalent. Voor Opus 4.7-werk dat de hele dag duurt, is dat de drempel waar tarieflimieten niet langer een dagelijkse ergernis zijn.

Maar er is een andere wiskunde die mij stoort. Het Pro-abonnement van $ 20/month is het startpunt waar de meeste ontwikkelaars daadwerkelijk mee beginnen. De Max 5x voor $ 100 is de upgrade die je krijgt als Pro je halverwege een taak begint te ghosten. Beide worden geleverd met wekelijkse gebruikslimieten (één voor alle modellen, één voor alleen Sonnet) die zeven dagen na het begin van uw sessie opnieuw worden ingesteld. Als je een bijproject op Pro bouwt en je wekelijkse quotum op dinsdagmiddag opraakt, wacht je tot volgende dinsdag. Of je hoest nog eens $ 80 op om te upgraden.

Voor klantwerk? Betaal het. De betrouwbaarheid is elke dollar waard.

Voor leren, prototypen en de persoonlijke projecten die ik misschien nooit zal verzenden? Met datzelfde geld zou ik een jaar kunnen experimenteren met zijprojecten als ik de goedkope dingen gewoon via goedkopere modellen zou leiden. Het addertje onder het gras: Claude Code is het beste agentic-coderingshulpmiddel dat ik ooit heb gebruikt. Het bewerken van bestanden, de sub-agents, het vaardigheidssysteem, de manier waarop het langlopende taken afhandelt: geen van de open-sourcealternatieven kan dit tot nu toe evenaren. Het was dus niet meer mogelijk om van instrument te wisselen om geld te besparen.

De proxy-aanpak is de schoonste oplossing die ik heb gezien. Bewaar het gereedschap. Verwissel de motor. Drie regels in een .env-bestand.

Als je de OpenRouter-route met Claude Code al hebt afgelegd met behulp van een aangepaste configuratie, is de proxy waar ik nu doorheen ga de meer flexibele neef: deze verwerkt drie backends, niet één, en normaliseert de eigenaardigheden van de provider die de handmatige installatie mist.

Hoe de proxy feitelijk werkt (en waarom dit ertoe doet)

Het mentale model is eenvoudiger dan het klinkt.

Claude Code praat standaard met Anthropic's API op api.anthropic.com. Elke prompt, elke tooloproep, elk streamingdeel gaat daarheen en komt terug. De proxy onderbreekt dat gesprek. U draait een kleine FastAPI-server op uw eigen machine (meestal localhost:8082) die dezelfde Anthropic-compatibele routes weergeeft die Claude Code verwacht (/v1/messages, /v1/messages/count_tokens, /v1/models). Wanneer Claude Code een verzoek naar dat lokale adres verzendt in plaats van naar dat van Anthropic, vertaalt de proxy de payload naar het formaat dat de daadwerkelijke backend wil, vuurt het af en vertaalt het antwoord terug naar de vorm die Claude Code weet te parseren.

De proxy doet het werk van een vertaler op een VN-top. Claude Code spreekt Anthropic. NVIDIA NIM spreekt OpenAI-smaak. OpenRouter spreekt zijn eigen dialect. Ollama spreekt iets dat in de buurt komt van OpenAI, maar met eigenaardigheden. De proxy luistert naar één en spreekt alle andere uit, on the fly, in realtime, inclusief de streaming-tokens, de tool-gebruiksblokken, de redenerings/thinking-blokken en de gebruiksmetagegevens die Claude Code gebruikt om de kosten bij te houden.

De specifieke repository die ik heb getest is [Ali Sharer's free-claude-code] (https://github.com/Alishahryar1/free-claude-code) op GitHub. De bronvideo waaruit ik werkte noemde het "free-cloud-code" - dat is een transcriptieartefact. De eigenlijke projectnaam is free-claude-code, door Alishahryar1. Ik wil dat van tevoren markeren, omdat de verkeerde naam je tijdens het zoeken in een konijnenhol van vorken en niet-gerelateerde projecten zal sturen.

Er is nog een tweede ding dat de proxy doet en dat gemakkelijk over het hoofd wordt gezien: het normaliseert providerfouten. Wanneer DeepSeek een 429-snelheidslimietantwoord genereert, of NVIDIA NIM een verkeerd ingedeeld tool-call-blok retourneert, of Ollama stilletjes een lang antwoord afkapt, crasht de onbewerkte fout Claude Code of stuurt deze naar een verwarde herhalingslus. De proxy vangt deze op, hervormt ze in fouten in de stijl van Anthropic, en Claude Code verwerkt ze op een elegante manier. Die enkele laag van foutnormalisatie is de reden waarom de proxy-aanpak in de praktijk werkt en een naïeve "just point at OpenRouter"-configuratie binnen tien minuten omvalt.

Nu – het deel dat ertoe doet als je dit daadwerkelijk probeert. De drie backends gedragen zich elk anders en de afwegingen zijn niet symmetrisch.

De drie backends, naast elkaar

Voordat ik door de configuratie loop, is dit waar u eigenlijk tussen kiest. Ik heb ze alle drie getest met hetzelfde project – Habitual, de gewoonte-tracker – en hier is hoe ze eruit sprongen.

NVIDIA NIM: Gratis, maar u moet zich wel aanmelden

NVIDIA NIM is de verrassende winnaar van het free-tier-spel. Vanaf april 2026 host NVIDIA's [build.nvidia.com platform] (https://build.nvidia.com/) meer dan 100 modellen met gratis API-toegang voor iedereen in de NVIDIA Developer Program. Geen creditcard. Geen betaald abonnement. U meldt zich aan, pakt een sleutel en krijgt 1000 gratis inferentiecredits met een snelheidslimiet van 40 verzoeken per minuut op de gratis laag.

Het belangrijkste model op NIM op dit moment is GLM-5 (744 miljard parameters), Z.ai's grensverleggende MoE-model dat in februari 2026 open source was. De benchmarkcijfers zijn reëel: GLM-4.7 (de vorige generatie) scoort 73,8% op SWE-bench en 41% op Terminal Bench 2.0, volgens de Cerebras GLM-4.7 aankondiging. GLM-5 en de recentere GLM-5.1 zijn opvallende stappen daarboven. Voor codeertaken die via Claude Code worden gerouteerd, presteren GLM-modellen ruim boven hun kostenklasse.

Het nadeel: NIM is langzamer dan OpenRouter. Streamen gaat prima. Een koude start op de grotere modellen kan 8-12 seconden duren voordat het eerste token verschijnt. Voor een Claude Code agentic-lus met tientallen gereedschapsoproepen per minuut tellen die seconden op.

OpenRouter: Goedkoop, snel, uitgestrekt

OpenRouter is de gateway die ik standaard gebruik. Het is een aggregator: u krijgt één API key, één eindpunt en toegang tot vrijwel elk commercieel en open-sourcemodel via één factureringsaccount. De prijsstelling komt het dichtst in de buurt van de LLM-wereld bij een grondstoffenmarkt.

Echte cijfers van OpenRouter's prijspagina vanaf mei 2026:

• DeepSeek V4 Flash: $0,14 per miljoen invoertokens, $0,28 per miljoen uitvoertokens
• DeepSeek V3.2: $0,252 invoer / $0,378 uitvoer per miljoen tokens
• DeepSeek V4 Pro: $0,435 input / $0,87 output per miljoen tokens (promotietarief, stijgend naar $1,74 / $3,48 na 5 mei 2026)
• DeepSeek R1: $0,70 input / $2,50 output per miljoen tokens

Vergelijk deze cijfers met de gepubliceerde [API-prijzen] van Anthropic (https://platform.claude.com/docs/en/about-claude/pricing): Opus 4.7 is $5 input en $25 output per miljoen tokens. Sonnet 4.6 is $3 invoer en $15 uitvoer. Zelfs Haiku 4.5 voor $ 1/$ 5 is ruimschoots duurder dan DeepSeek V4 Flash.

Voor Habitual heb ik ongeveer 850.000 tokens verbrand tijdens de volledige build: planning, steigers, drie iteraties, debuggen, polijsten. Op Opus 4.7 zou dat ongeveer $ 7-9 aan API-kosten hebben opgeleverd. Op DeepSeek V4 Flash tot en met OpenRouter kostte het me 23 cent. Drieëntwintig cent. Ik moet het blijven zeggen, want elke keer als ik de wiskunde doe, ben ik nog steeds een beetje verbijsterd.

Een correctie die de moeite waard is: de bronvideo waaruit ik dit bericht heb opgebouwd, verwees naar "Anthropic's DeepSeek Flash V4." DeepSeek V4 Flash is een DeepSeek-model, niet een Anthropic-model. DeepSeek en Anthropic zijn volledig afzonderlijke bedrijven - DeepSeek is een Chinees AI-lab, Anthropic is het bedrijf dat Claude maakt. De naamgeving wordt wazig bij snel bewegende inhoud, maar het onderscheid is van belang omdat het de manier verandert waarop u over gegevensstromen denkt en welke servicevoorwaarden van toepassing zijn.

Ollama: Gratis, privé, hardwaregebonden

Ollama voert modellen volledig uit op uw lokale computer. Geen enkel API-gesprek verlaat uw laptop. Geen enkele derde partij ziet uw code. Voor gevoelig werk of NDA-werk is dit de enige optie op de lijst die daadwerkelijk privé is.

De vangst is hardware. De huidige generatie omvat Llama 4 (het vlaggenschip van Meta) en Gemma 4 (de open-weight-serie van Google). Op Apple Silicon maakt Ollama v0.19+ automatisch gebruik van Apple's MLX-framework voor snellere gevolgtrekkingen - dat is de ontgrendeling die lokale modellen echt bruikbaar maakt op een MacBook. Volgens [Unsloth's Gemma 4-documentatie] (https://unsloth.ai/docs/models/gemma-4) halen de kleinere varianten – E2B en E4B – respectievelijk ongeveer 95 en 57 tokens per seconde op een Mac van de huidige generatie. De 26B-variant wordt aanbevolen voor 24 GB+ uniform geheugen.

Ik heb Gemma 4 12B lokaal uitgevoerd op een MacBook uit de M-serie met 32 ​​GB RAM. Bewerkingen in één bestand en kleine refactoren werkten prima. Op het moment dat Claude Code probeerde vier bestanden in de context te laden voor een wijziging van meerdere bestanden, begon het model te vertragen - 8 tot 12 seconden tussen tooloproepen, en de uitvoerkwaliteit daalde bij alles waarbij meer dan twee bestanden tegelijk in gedachten moesten worden gehouden.

Als je een werkplek hebt met een discrete NVIDIA GPU, verandert dit verhaal compleet. Op een desktop met een 4090 of beter is de Llama 4 70B echt snel en blijft de kwaliteit bij complexe taken behouden. Op een MacBook zonder die GPU? Gebruik Ollama voor korte, gerichte taken waarbij privacy belangrijk is. Gebruik OpenRouter of NIM voor iets anders. Er is ook een bekende streamingbug in Ollama v0.20.3 die de tool-call-reacties van Gemma 4 verkeerd verwerkt - vastzetten naar v0.19.x of wacht op de oplossing als je die tegenkomt.

Nu - de daadwerkelijke opstelling.

Stap voor stap: de proxy laten werken

Dit is het gedeelte dat ik zou willen als ik helemaal opnieuw zou beginnen. Ik neem aan dat je Claude Code al hebt geïnstalleerd. Als je dat niet doet, installeer het dan eerst via de [officiële Anthropic-instructies] (https://docs.claude.com/en/docs/claude-code) — de proxy vervangt Claude Code niet, hij zit eronder.

Stap 1: Vereisten installeren

Je hebt Python 3.14 en uv (de snelle Python-pakketbeheerder) nodig. Op macOS:

curl -LsSf https://astral.sh/uv/install.sh | sh

# Install Python 3.14 via uv
uv python install 3.14

Op Windows PowerShell:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
uv python install 3.14

De reden voor uv in plaats van pip: het is ongeveer 10-100x sneller voor het oplossen van afhankelijkheden, en pyproject.toml van de proxy-opslagplaats is daarvoor ingesteld. U kunt pip gebruiken als u erop aandringt, maar uv zorgt ervoor dat de installatie onmiddellijk plaatsvindt.

Stap 2: Kloon de opslagplaats

git clone https://github.com/Alishahryar1/free-claude-code.git
cd free-claude-code
cp .env.example .env

Die stap .env.example → .env is waar de meeste mensen over struikelen. Het .env-bestand is standaard verborgen op macOS. Als je het niet kunt zien in Finder, druk dan op Cmd+Shift+. (punt) om tussen verborgen bestanden te schakelen. In de terminal laat ls -la het zien. In VS Code wordt dit standaard weergegeven. Dit klinkt triviaal, maar de eerste keer dat ik me afvroeg waarom mijn bewerkingen niet bleven hangen, verloor ik tien minuten: ik was een bestand in een andere map aan het bewerken.

Stap 3: verkrijg uw API-sleutels

Kies een backend. U kunt ze alle drie later configureren, maar begin met één om te bevestigen dat de proxy werkt.

OpenRouter: Meld u aan op openrouter.ai, voeg $ 5 aan tegoed toe (hier kunt u weken mee doen) en pak een API key van het dashboard. Vijf dollar voor OpenRouter is genoeg om verschillende volledige applicaties te bouwen via DeepSeek V4 Flash.

NVIDIA NIM: Meld u aan op build.nvidia.com, sluit u aan bij de NVIDIA Developer Program (gratis) en genereer een API key. Je krijgt direct 1.000 gratis credits. Geen creditcard vereist.

Ollama: Installeer vanaf ollama.com en haal vervolgens een model op. Voor coderen op een MacBook met 16-32GB RAM begint u met ollama pull gemma4:e4b. Voor een werkstation met serieuze GPU, ollama pull llama4:70b. Geen API key nodig: Ollama wordt lokaal uitgevoerd.

Stap 4: Bewerk .env

Open .env in de editor van uw keuze. Het bestand heeft voor elke backend blokken met commentaar. U verwijdert de commentaar die u wilt en vult de sleutel en de modelnaam in. Hier is een werkende OpenRouter-configuratie:

# Backend selection
PROVIDER=openrouter

# OpenRouter
OPENROUTER_API_KEY=sk-or-v1-xxxxxxxxxxxxxxxxx
OPENROUTER_MODEL=deepseek/deepseek-v4-flash

# Proxy port
PORT=8082

Voor NVIDIA NIM, wissel naar:

PROVIDER=nvidia_nim
NVIDIA_API_KEY=nvapi-xxxxxxxxxxxxxxxxx
NVIDIA_MODEL=zai-org/glm-5
PORT=8082

Voor Ollama (geen sleutel nodig):

PROVIDER=ollama
OLLAMA_MODEL=gemma4:e4b
OLLAMA_HOST=http://localhost:11434
PORT=8082

Stap 5: Start de proxy

Vanuit de repository:

uv run main.py

Je zou iets als Uvicorn running on http://0.0.0.0:8082 moeten zien. Laat deze terminal open. De proxy moet actief blijven terwijl u Claude Code gebruikt.

Stap 6: Wijs Claude Code naar de proxy

Stel in een nieuwe terminal de omgevingsvariabele in die Claude Code vertelt waar verzoeken naartoe moeten worden gestuurd en start vervolgens:

export ANTHROPIC_BASE_URL=http://localhost:8082
export ANTHROPIC_API_KEY=anything
claude

De ANTHROPIC_API_KEY-waarde doet er niet toe: de proxy negeert deze en gebruikt de echte sleutel van .env om te authenticeren met de daadwerkelijke backend. Maar Claude Code weigert te starten zonder een waarde in die variabele, dus stel deze in op iets dat niet leeg is.

Als u wilt dat dit de standaard is voor een project, zet u deze exports neer in een .envrc-bestand (met direnv) of in een project-lokaal opstartscript. Ik bewaar een claude-cheap shell-alias die beide vars exporteert en Claude Code in één keer start.

Dat is de hele opzet. Zes stappen, misschien tien minuten als je voorzichtig beweegt. De eerste keer dat ik het doornam, kostte het me ongeveer twintig - het grootste deel daarvan was de verborgen .env-bestandsverwarring en een verkeerde modelnaam in de OpenRouter-configuratie die een verwarrende 404 retourneerde.

Als je een van mijn andere Claude Code workflowhandleidingen hebt gevolgd, is dit dezelfde Claude Code die je al gebruikt: elk commando, elk slash-commando, elke vaardigheid. Het enige verschil is welk model de gevolgtrekking onder de motorkap doet.

Hoe het was om Habitual daadwerkelijk te bouwen

Ik wil de echte build bespreken, niet omdat de app er toe doet, maar omdat de ruwe randen pas zichtbaar worden als je een echt project doorvoert. Habitual is een gewoonte-tracker: dagelijkse check-ins, streak-telling, een kalender-heatmap, de standaarddingen. Hier ziet u hoe het op elke backend ging.

DeepSeek V4 Flash via OpenRouter

Dit was het werkpaard. Ik begon met een prompt van één alinea: "Bouw een minimale gewoonte-tracker, een enkele gebruiker, een webapp, Tailwind, vanille JS, dagelijkse check-in met streak-teller en een kalenderraster van 30 dagen." Claude Code (loopt via de proxy op DeepSeek V4 Flash) plande de structuur, stelde de bestanden op, schreef de HTML en JavaScript en voerde het uit.

De eerste iteratie was ruw: de streak-logica was één voor één afwijkend en het agendaraster had een UTC- versus lokale tijd-bug. Ik heb gevraagd om beide te repareren. Het heeft ze opgelost. Ik heb gevraagd om een ​​'dag overslaan'-optie toe te voegen die de reeks niet doorbreekt (rustdagen voor duurzame gewoonten). Het refactorde de streak-berekening netjes.

Drie iteraties later, werkende app. Totale tokenuitgaven: 850.000 tokens, ongeveer gelijk verdeeld over input en output. Totale kosten: ongeveer $ 0,21. De uitvoerkwaliteit was merkbaar lager dan wat Opus 4.7 zou produceren - de namen van variabelen waren een beetje algemeen, het commentaar was schaarser, de foutafhandeling was minimaal - maar voor een zijproject waarbij ik alles wat ik bewaar, ga herstructureren, is dat prima.

De enige plek waar DeepSeek V4 Flash zichtbaar moeite mee had, was toen ik het vroeg om IndexedDB-persistentie toe te voegen met de juiste migratielogica. Opus 4.7 zou het schema, de migratierunner en de versieafhandeling in één keer hebben geschreven. DeepSeek schreef het schema prima, miste de migratie volledig en ik moest het twee keer vragen voordat het iets implementeerde dat een schemawijziging zou overleven. Voor het meeste CRUD-werk is de kloof onzichtbaar. Voor alles wat zorgvuldig systeemdenken vereist, zult u het verschil voelen.

GLM-5 via NVIDIA NIM

Toen de app eenmaal werkte, heb ik hetzelfde project helemaal opnieuw opgebouwd op NIM met GLM-5 om te vergelijken. GLM-5 is, op papier, een veel groter model dan DeepSeek V4 Flash - 744B-parameters MoE versus de kleinere flitsvariant van DeepSeek. En de uitvoerkwaliteit liet het zien. De namen van de variabelen waren beter. De opmerkingen waren bedachtzamer. De IndexedDB-implementatie was correct bij de eerste doorgang.

De wisselwerking was snelheid. Elke gereedschapsoproep duurde merkbaar langer: noem het 4-8 seconden versus 2-3 op OpenRouter. Voor een agentic-workflow met meer dan 40 tooloproepen in een sessie is dat een pluspunt. De volledige bouw duurde ongeveer twee keer zo lang, ook al had het model minder heen en weer nodig omdat de uitvoer de eerste keer van hogere kwaliteit was.

NIM is ook gratis op het niveau van ontwikkelaarskrediet, waardoor de snelheidsafweging gemakkelijker te accepteren is. Als ik een open-weight-inferentie van productiekwaliteit zou doen, zou GLM-5 op NIM mijn standaard zijn. Voor snelle iteratie bij wegwerpprojecten wint OpenRouter alleen op reactievermogen.

Gemma 4 12B via Ollama

Dit is waar de afwegingen luid werden. Op mijn MacBook met 32 ​​GB uniform geheugen laadde Gemma 4 12B prima en voerde de kleine dingen uit (bewerkingen van één bestand, eenvoudige refactoren, dingen benoemen) met ongeveer 30-40 tokens per seconde. Echt bruikbaar.

Op het moment dat Claude Code probeerde vier of vijf bestanden in context te laden voor een refactor van meerdere bestanden, ging het mis. De streaming vertraagde dramatisch. Tooloproepen begonnen een time-out te vertonen. Eén daarvan heeft de middenreactie stilzwijgend afgekapt, wat de foutmodus is die de proxy niet volledig kan herstellen: Ollama retourneert gewoon minder dan zou moeten en Claude Code denkt dat de taak is voltooid.

Voor Habitual specifiek kwam Gemma 4 12B door de initiële steiger, maar kon de streak-logica-refactor niet aan zonder dat ik het bestand voor bestand met de hand moest invoeren. Op een werkstation met een 4090 zou dit geen probleem zijn. Op een MacBook zonder een discrete GPU, behandel de lokale Ollama als een hulpmiddel voor korte, gerichte taken in plaats van als een dagelijkse Claude Code-chauffeur.

Er is een diepgaander gesprek gaande over lokaal-eerste AI-ontwikkeling die de moeite waard is - ik ging er dieper op in [mijn Gemma 4 lokale installatiepost] (https://www.mejba.me/gemma-chat-offline-vibe-coding-mac) - maar de korte versie is: Apple Silicon is echt indrukwekkend voor lokale gevolgtrekking, en het is nog steeds geen vervanging voor cloud-tier-modellen op agentic-coderingsworkflows.

De echte krachtbeweging: multi-modelorkestratie

Hier wordt het interessanter dan geld besparen. Zodra je een proxy hebt die naar verschillende modellen kan routeren, ben je één stap verwijderd van het orkestratiepatroon dat stilletjes de standaard aan het worden is voor serieuze AI-ontwikkeling.

Het idee: gebruik Opus 4.6 (of 4.7) op uw betaalde Anthropic-abonnement als planner en orkestrator. Laat het een complexe taak opsplitsen in afzonderlijke subtaken. Delegeer vervolgens elke subtaak naar een goedkoop model – DeepSeek V4 Flash, GLM-5, wat dan ook – via de proxy. Opus beoordeelt de resultaten, integreert ze en verbrandt zijn dure context alleen maar met het denken met een hoge hefboomwerking.

In de praktijk lijkt dit erop dat twee Claude Code-instanties naast elkaar worden uitgevoerd. Eén daarvan is uw hoofdsessie op Anthropic-direct, waarin u de orkestratie en de architecturale beslissingen neemt. De andere is de proxysessie die op een goedkope backend draait en het routinematige implementatiewerk uitvoert: genereer het testbestand, schrijf de standaardtekst, update de documenten, refactoreer deze ene functie. Je geeft subtaken van de eerste naar de tweede en keert dan terug naar de eerste om te integreren.

Ik maak hier al een paar maanden variaties op. De symbolische wiskunde wordt snel overtuigend. Een typische dag waarop ik 3-4 miljoen tokens van Opus op abonnement zou kunnen verbranden, wordt misschien 800K Opus (de planning, de integratie, de harde delen) en 3M DeepSeek via de proxy (de uitvoering, de standaard, de routine-refactoren). De uitvoerkwaliteit is niet te onderscheiden van het eindproduct. De tijdsbesteding is vergelijkbaar. Het kostenverschil is dramatisch.

Dit patroon weerspiegelt wat ik heb besproken in Anthropic's agent SDK-handleiding - de toekomst van agentic-codering is niet "één gigantisch model doet alles", maar "één goed model orkestreert veel goedkope modellen." De proxy is het ontbrekende onderdeel dat dit praktisch maakt zonder aangepaste orkestratiecode te schrijven.

Wat deze aanpak fout doet (het eerlijke deel)

Ik zou liegen als ik zou zeggen dat dit een directe vervanging was voor de betaalde Claude Code. Er zijn echte beperkingen en die moet je kennen voordat je een echt project aan deze stapel commit.

Goedkope modellen missen fijne details aan de randen van complexe taken. Ik heb dit vermeld bij de IndexedDB-migratie. Het komt het meest tot uiting in: complexe async/concurrency-redeneringen, subtiele beveiligingsimplicaties, diepgaande refactoren die veel bestanden tegelijk raken, en alles dat een goed begrip van architecturale afwegingen vereist. Bij 70-80% van het typische codeerwerk zult u er niets van merken. Voor de harde 20% voel je de kloof.

Sommige Claude Code-functies gaan uit van Anthropic-direct. De snelle modus (de nieuwe laag met lage latentie in Claude Code 2.x) geeft fouten op niet-Anthropic-backends omdat deze afhankelijk is van Anthropic-specifieke streaming-optimalisaties. Sommige vaardigheden en plug-ins die Claude-specifieke toolgebruiksformaten gebruiken, kunnen zich vreemd gedragen. De meeste kernfuncties – bestandsbewerking, sub-agents, slash-opdrachten, het vaardigheidssysteem – werken prima. Randgevallen zullen u doen struikelen.

Lange sessies verminderen sneller op goedkope modellen dan op Opus. Ik heb ontdekt dat ongeveer 50.000 tokens in een sessie de uitvoerkwaliteit op DeepSeek V4 Flash merkbaar begint te dalen. Het model verliest eerdere beslissingen uit het oog, spreekt zichzelf tegen en begint functiesignaturen van eerder in het gesprek te hallucineren. De oplossing is mechanisch: als je tegen die muur aanloopt, sluit je Claude Code af, start je opnieuw op met een nieuwe context en laad je de relevante bestanden opnieuw. In het 1M-contextvenster van Opus 4.7 is dit zelden nodig tot veel dieper in een sessie.

Lokale modellen op een MacBook zonder een GPU zijn echt traag. Ik heb dit besproken in de sectie Ollama, maar het is de moeite waard om te herhalen. Behandel Ollama-op-MacBook als een privacytool, niet als een productiviteitstool. Voor echte lokale inferentieprestaties hebt u NVIDIA GPU-hardware nodig.

Privacy en gegevensstroom veranderen. Wanneer u via OpenRouter of NIM routeert, passeren uw aanwijzingen en code hun infrastructuur. OpenRouter heeft een redelijk privacybeleid en traint niet standaard op uw gegevens, maar het is een extra sprong en een extra bedrijf dat uw code ziet. Voor klantwerk, NDA-werk of iets gevoeligs: blijf op Anthropic-direct of ga voor volledig Ollama-local. Geen middenweg.

De besparingen op abonnementen hebben een plafond. Als u al voor Max ($100-200/month) betaalt, bespaart u niet het hele abonnement door persoonlijke projecten via de proxy te routeren. U wilt nog steeds Max voor klant- en productiewerk. De besparingen verschijnen als "Ik koop geen API-credits meer bovenop mijn abonnement voor persoonlijke experimenten", wat reëel maar begrensd is.

Het modellenaanbod beweegt ook snel. De namen in dit bericht – DeepSeek V4 Flash, GLM-5, GLM-5.1, Gemma 4 – waren actueel vanaf mei 2026. Tegen de tijd dat u dit leest, zijn er mogelijk nieuwere vlaggenschepen tegen lagere prijzen. Controleer de prijspagina van OpenRouter en de NVIDIA NIM-modellencatalogus voordat u zich aan een specifiek model in uw .env vastlegt.

Wat ik vandaag tegen iemand zou zeggen

Als je erover denkt om dit te proberen, dan is dit het pad dat ik zou volgen als ik opnieuw zou beginnen.

Besteed tien minuten aan de OpenRouter-installatie met DeepSeek V4 Flash. Geef $ 5 aan tegoed af. Laat de proxy draaien. Bouw iets kleins: een script, een kleine app, alles waar je anders een paar minuten abonnementsquotum aan zou besteden. Merk op hoe het voelt. De wrijving is bijna nul en de kosten zijn bijna nul.

Als die ervaring je boeit (het boeide mij), stel dan NVIDIA NIM in als je tweede backend. De gratis laag met GLM-5 is echt goed en geeft je een terugval van hogere kwaliteit als DeepSeek V4 Flash niet genoeg is. Het wisselen van backends is één regel in .env en een herstart van de proxy.

Maak je geen zorgen over Ollama tenzij je een werkstation hebt met een echte GPU of als je specifiek alleen lokale privacy nodig hebt. Op een MacBook zal de ervaring je teleurstellen en dat is de verkeerde eerste indruk van wat verder een geweldige toolchain is.

Als u zich eenmaal op uw gemak voelt, kunt u het orkestratiepatroon proberen. Voer Opus uit op Anthropic-direct voor de planning en architectuur. Voer DeepSeek uit via de proxy voor de uitvoering. De kostenbesparingen lopen snel op en de workflow voelt na een paar dagen verrassend natuurlijk aan.

En blijf voor Max betalen voor het werk dat er toe doet. Deze proxybenadering is geen vervanging voor waar Anthropic u voor in rekening brengt: betrouwbaarheid, ondersteuning, het absoluut beste model in zijn klasse voor de moeilijke problemen. Het is een manier om uw experimenteerbudget met een orde van grootte uit te breiden zonder de Claude Code-interface waar u al van houdt op te geven.

De Habitual-app staat nog steeds op mijn telefoon. Ik controleer het elke ochtend. Het kostte me 23 cent om te bouwen, het draait volledig in mijn browser en ik gebruik het echt. Als ik volgende week gewoontecategorieën of wekelijkse rapporten of een notificatiesysteem wil toevoegen, start ik de proxy, wijs Claude Code naar OpenRouter en herhaal ik voor nog een handvol centen. Dat is de ontgrendeling.

De rest van 2026 wordt een wilde rit voor AI-gereedschappen. Modellen worden goedkoper. Opties met een open gewicht halen de grensoverschrijdende gesloten modellen sneller in dan iemand had voorspeld. De proxy-aanpak is op dit moment de juiste vorm: behoud de beste UX, routeer naar welk model dan ook dat zinvol is voor de taak, en laat de markt voor gevolgtrekkingen zijn ding doen.

Bouw het zijproject. Bouw het via de proxy. Besteed de dollar die je hebt bespaard aan koffie.

Veelgestelde vragen

Hoeveel kost het om Claude Code uit te voeren via de gratis Claude Code proxy?

Voor de meeste persoonlijke projecten lopen de kosten uiteen van helemaal gratis (NVIDIA NIM-credits of Ollama lokaal) tot minder dan $ 1 per app-build (DeepSeek V4 Flash op OpenRouter voor $ 0,14/M invoertokens). Hetzelfde project op directe Anthropic API zou $ 5 - $ 10 kosten. Installatie is gratis; uw enige uitgave is de gevolgtrekking op welke backend u ook kiest.

Werkt de proxy met alle Claude Code-functies?

De meeste functies werken: bestandsbewerking, sub-agents, slash-opdrachten, vaardigheden, MCP servers, workflows met meerdere bestanden. De opmerkelijke uitzondering is de snelle modus, die afhankelijk is van Anthropic-specifieke streaming-optimalisaties en fouten op niet-Anthropic-backends. Sommige plug-ins die Anthropic-specifieke tool-gebruiksformaten gebruiken, kunnen zich ook vreemd gedragen. Zie de implementatie-walkthrough hierboven voor de volledige installatie.

Is het veilig om mijn code te verzenden via OpenRouter of NVIDIA NIM?

Voor persoonlijke projecten en open-sourcewerk hanteren beide providers een redelijk privacybeleid en trainen ze niet standaard op uw gegevens. Voor clientwerk, NDA-gebonden code of iets anders met inloggegevens, blijf op Anthropic-direct of gebruik Ollama lokaal - uw code verlaat nooit uw machine met Ollama. Er bestaat geen veilige middenweg voor gevoelig werk.

Wat is het beste gratis model om met de proxy te gebruiken?

Voor codering is GLM-5 op NVIDIA NIM de sterkste gratis optie: 744B-parameters, eersteklas kwaliteit, gratis bij aanmelding voor ontwikkelaars. DeepSeek V4 Flash op OpenRouter is de goedkoopste met $ 0,14/M invoertokens (niet gratis, maar dichtbij), en is sneller dan NIM. Alleen voor lokaal: Gemma 4 E4B op Ollama werkt op Apple Silicon, maar heeft hardwarelimieten.

Kan ik schakelen tussen backends zonder opnieuw te installeren?

Ja. Wijzig de PROVIDER-waarde in uw .env-bestand, start de proxy opnieuw met uv run main.py en Claude Code zal de nieuwe backend gebruiken bij zijn volgende verzoek. U hoeft Claude Code zelf niet opnieuw op te starten. Veel gebruikers bewaren meerdere .env-bestanden (.env.openrouter, .env.nim, .env.ollama) en koppelen de actieve bestanden symbolisch.

Laten we samenwerken

Wilt u AI-systemen bouwen, workflows automatiseren of uw technische infrastructuur schalen? Ik help je graag.

• Fiverr (aangepaste builds en integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (ondernemingsoplossingen): ramlit.com
• ColorPark (ontwerp en branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io