Proxy gratuito do Claude Code: NVIDIA, OpenRouter e Ollama testados

Criei um aplicativo rastreador de hábitos chamado Habitual no fim de semana passado. Três iterações, dois redesenhos, um banco de dados real, lógica de sequências de trabalho. A coisa toda – do início ao fim – me custou menos do que o preço de um chiclete.

Se eu o tivesse construído da maneira que normalmente faço, em minha assinatura Claude Max com Opus 4.7 fazendo o trabalho pesado, o mesmo projeto teria consumido algo entre cinco e dez dólares de crédito API além de minha assinatura mensal de US$ 200. Não é uma fortuna. Mas para um projeto paralelo que posso excluir na próxima semana, é exatamente o tipo de custo que me faz pensar duas vezes antes de abrir o terminal à meia-noite.

Aqui está o que mudou. Mantive Claude Code — a CLI, o agent, a execução da ferramenta, tudo — exatamente igual. Não mudei para um IDE diferente. Não aprendi um novo fluxo de trabalho. Acabei de colocar um pequeno proxy de código aberto embaixo dele, e esse proxy redirecionou silenciosamente todas as chamadas API para um modelo gratuito ou quase gratuito em uma infraestrutura diferente. NVIDIA NIM. OpenRouter. Ollama em execução no meu MacBook. Três backends, um proxy, a mesma interface Claude Code que já conheço.

O resultado não é perfeito. Eu vou entrar onde ele quebra. Mas para prototipagem, aprendizado, projetos paralelos e a longa cauda de “Quero tentar algo, mas não quero pensar em custo” – esta é a coisa mais próxima de um código de trapaça que encontrei em 2026.

Por que procurei isso em primeiro lugar

Meu plano Claude Max é $ 200/month.. Não estou reclamando - eu queimo tudo toda semana no trabalho do cliente e pagaria o dobro pela confiabilidade. De acordo com o [detalhamento de preços atual] do Anthropic (https://support.claude.com/en/articles/11049741-what-is-the-max-plan), Max 20x me dá cerca de 20x a janela de uso do nível Pro, o que equivale a cerca de 220.000 tokens a cada cinco horas no equivalente API. Para trabalho Opus 4.7 de dia inteiro, esse é o limite em que os limites de taxa deixam de ser um incômodo diário.

Mas há uma matemática diferente que me incomoda. O plano Pro de $ 20/month é o ponto de entrada pelo qual a maioria dos desenvolvedores começa. O Max 5x de US $ 100 é a atualização que você obtém quando o Pro começa a fantasma no meio da tarefa. Ambos vêm com limites de uso semanais – um para todos os modelos, um apenas para Sonnet – que são redefinidos sete dias a partir do início da sessão. Se você estiver construindo um projeto paralelo no Pro e estourar sua cota semanal em uma tarde de terça-feira, espere até a próxima terça. Ou você desembolsa outros US$ 80 para fazer um upgrade.

Para trabalho do cliente? Pague. A confiabilidade vale cada dólar.

Para aprendizado, prototipagem e projetos pessoais que talvez nunca envie? Esse mesmo dinheiro poderia me comprar um ano de experimentação em projetos paralelos se eu apenas encaminhasse o material barato para modelos mais baratos. O problema: Claude Code é a melhor ferramenta de codificação agentic que já usei. A edição de arquivos, o sub-agents, o sistema de habilidades, a maneira como ele lida com tarefas de longa duração – nenhuma das alternativas de código aberto corresponde a isso ainda. Portanto, trocar de ferramentas para economizar dinheiro estava fora de questão.

A abordagem de proxy é a solução alternativa mais limpa que já vi. Guarde a ferramenta. Troque o motor. Três linhas em um arquivo .env.

Se você já seguiu a rota OpenRouter com Claude Code usando uma configuração personalizada, o proxy que estou prestes a percorrer é o primo mais flexível - ele lida com três back-ends, não um, e normaliza as peculiaridades do provedor que faltam na configuração manual.

Como o proxy realmente funciona (e por que é importante)

O modelo mental é mais simples do que parece.

Claude Code, por padrão, se comunica com o API de Anthropic em api.anthropic.com. Cada prompt, cada chamada de ferramenta, cada pedaço de streaming vai até lá e volta. O proxy interrompe essa conversa. Você ativa um pequeno servidor FastAPI em sua própria máquina - geralmente localhost:8082 - que expõe as mesmas rotas compatíveis com Anthropic que Claude Code espera (/v1/messages, /v1/messages/count_tokens, /v1/models). Quando Claude Code envia uma solicitação para esse endereço local em vez de Anthropic, o proxy traduz a carga útil em qualquer formato que o back-end real deseja, aciona-o e traduz a resposta de volta para a forma que Claude Code sabe como analisar.

O procurador está fazendo o trabalho de um tradutor numa cimeira da ONU. Claude Code fala Anthropic. NVIDIA NIM fala com sabor OpenAI. OpenRouter fala seu próprio dialeto. Ollama fala algo próximo de OpenAI, mas com peculiaridades. O proxy escuta um e fala todos os outros, dinamicamente, em tempo real, incluindo os tokens de streaming, os blocos de uso de ferramentas, os blocos de raciocínio/thinking e os metadados de uso que Claude Code usa para rastrear custos.

O repositório específico que testei é código de claude livre de Ali Sharer no GitHub. O vídeo de origem em que trabalhei o chamou de "código de nuvem livre" - é um artefato de transcrição. O nome real do projeto é código de claude livre, de Alishahryar1. Quero sinalizar isso antecipadamente porque o nome errado o levará para uma toca de garfos e projetos não relacionados quando você pesquisar.

Há uma segunda coisa que o proxy faz que é fácil de ignorar: ele normaliza os erros do provedor. Quando DeepSeek lança uma resposta de limite de taxa 429, ou NVIDIA NIM retorna um bloco de chamada de ferramenta malformado, ou Ollama trunca silenciosamente uma resposta longa, o erro bruto travaria o Claude Code ou o enviaria para um loop de nova tentativa confuso. O proxy os captura, os remodela em erros no estilo Anthropic e o Claude Code os trata normalmente. Essa única camada de normalização de erros é o motivo pelo qual a abordagem de proxy funciona na prática e uma configuração ingênua "apenas aponte para OpenRouter" falha em dez minutos.

Agora – a parte que importa quando você realmente tenta fazer isso. Cada um dos três back-ends se comporta de maneira diferente e as compensações não são simétricas.

Os três back-ends, lado a lado

Antes de prosseguir com a configuração, aqui está o que você realmente está escolhendo. Testei todos os três com o mesmo projeto – Habitual, o rastreador de hábitos – e foi assim que eles funcionaram.

NVIDIA NIM: Gratuito, mas você se inscreve

NVIDIA NIM é o vencedor surpresa do jogo de nível gratuito. Em abril de 2026, a plataforma build.nvidia.com do NVIDIA hospedava mais de 100 modelos com acesso API gratuito para qualquer pessoa no NVIDIA Developer Program. Sem cartão de crédito. Nenhum plano pago. Você se inscreve, pega uma chave e recebe 1.000 créditos de inferência gratuitos com um limite de taxa de 40 solicitações por minuto no nível gratuito.

O modelo principal no NIM agora é GLM-5 (744 bilhões de parâmetros), o modelo MoE de fronteira da Z.ai que foi de código aberto em fevereiro de 2026. Os números de benchmark são reais – GLM-4.7 (a geração anterior) atinge 73,8% no SWE-bench e 41% no Terminal Bench 2.0, de acordo com o anúncio do Cerebras GLM-4.7. GLM-5 e o mais recente GLM-5.1 são passos visíveis acima disso. Para tarefas de codificação roteadas por meio do Claude Code, os modelos GLM estão bem acima de sua classe de custo.

A desvantagem: NIM é mais lento que OpenRouter. A transmissão está bem. As partidas a frio nos modelos maiores podem levar de 8 a 12 segundos antes do primeiro token. Para um loop Claude Code agentic com dezenas de chamadas de ferramenta por minuto, esses segundos se somam.

OpenRouter: barato, rápido e amplo

OpenRouter é o gateway padrão. É um agregador: você obtém um API key, um endpoint e acesso a quase todos os modelos comerciais e de código aberto por meio de uma única conta de cobrança. O preço é o mais próximo que o mundo LLM chega de um mercado de commodities.

Números reais da página de preços de OpenRouter em maio de 2026:

DeepSeek V4 Flash: US$ 0,14 por milhão de tokens de entrada, US$ 0,28 por milhão de tokens de saída
DeepSeek V3.2: US$ 0,252 de entrada / US$ 0,378 de saída por milhão de tokens
DeepSeek V4 Pro: US$ 0,435 de entrada/US$ 0,87 de saída por milhão de tokens (taxa promocional, aumentando para US$ 1,74/US$ 3,48 após 5 de maio de 2026)
DeepSeek R1: US$ 0,70 de entrada / US$ 2,50 de saída por milhão de tokens

Compare esses números com os [preços API] publicados de Anthropic (https://platform.claude.com/docs/en/about-claude/pricing): Opus 4.7 custa US$ 5 de entrada e US$ 25 de saída por milhão de tokens. Sonnet 4.6 custa $ 3 de entrada e $ 15 de saída. Mesmo o Haiku 4.5 por US$ 1/US$ 5 é mais caro do que o DeepSeek V4 Flash por uma ampla margem.

Para Habitual, queimei cerca de 850.000 tokens em toda a construção – planejamento, estrutura, três iterações, depuração, polimento. Em Opus 4.7, isso custaria cerca de US $ 7-9 no custo de API. Do DeepSeek V4 Flash ao OpenRouter, custou-me 23 centavos. Vinte e três centavos. Tenho que continuar dizendo isso porque toda vez que faço as contas ainda fico um pouco atordoado.

Uma correção que vale a pena fazer: o vídeo de origem do qual construí esta postagem referia-se a "DeepSeek Flash V4 do Anthropic". DeepSeek V4 Flash é um modelo DeepSeek, não Anthropic. DeepSeek e Anthropic são empresas completamente separadas – DeepSeek é um laboratório chinês AI, Anthropic é a empresa que fabrica Claude. A nomenclatura fica confusa em conteúdo de movimentação rápida, mas a distinção é importante porque muda a forma como você pensa sobre o fluxo de dados e quais termos de serviço se aplicam.

Ollama: gratuito, privado, vinculado a hardware

Ollama executa modelos inteiramente em sua máquina local. Nenhuma chamada API sai do seu laptop. Nenhum terceiro vê seu código. Para trabalhos confidenciais ou NDA, esta é a única opção da lista que é realmente privada.

O problema é o hardware. A geração atual inclui Llama 4 (carro-chefe da Meta) e Gemma 4 (série de peso aberto do Google). No Apple Silicon, o Ollama v0.19+ usa automaticamente a estrutura MLX da Apple para inferência mais rápida – esse é o desbloqueio que torna os modelos locais genuinamente utilizáveis em um MacBook. De acordo com a [documentação Gemma 4 da Unsloth] (https://unsloth.ai/docs/models/gemma-4), as variantes menores – E2B e E4B – atingem cerca de 95 e 57 tokens por segundo, respectivamente, em um Mac da geração atual. A variante 26B é recomendada para mais de 24 GB de memória unificada.

Executei Gemma 4 12B localmente em um MacBook da série M com 32 GB de RAM. Edições de arquivo único e pequenos refatoradores funcionaram bem. No momento em que Claude Code tentou carregar quatro arquivos no contexto para uma alteração de vários arquivos, o modelo começou a ficar lento – 8 a 12 segundos entre as chamadas de ferramenta, e a qualidade de saída caiu em qualquer coisa que exigisse manter mais de dois arquivos em mente ao mesmo tempo.

Se você tiver uma estação de trabalho com um NVIDIA GPU discreto, essa história muda completamente. Em um desktop com 4090 ou superior, o Llama 4 70B é genuinamente rápido e a qualidade se mantém em tarefas complexas. Em um MacBook sem aquele GPU? Use Ollama para tarefas curtas e focadas onde a privacidade é importante. Use OpenRouter ou NIM para qualquer outra coisa. Há também um conhecido bug de streaming em Ollama v0.20.3 que manipula incorretamente as respostas de chamada de ferramenta do Gemma 4 - fixe em v0.19.x ou espere pela correção se você acertar.

Agora – a configuração real.

Passo a passo: Colocando o proxy em execução

Esta é a seção que eu desejaria se estivesse começando do zero. Presumo que você já tenha o Claude Code instalado. Caso contrário, instale-o primeiro por meio das [instruções oficiais do Anthropic] (https://docs.claude.com/en/docs/claude-code) - o proxy não substitui o Claude Code, ele fica abaixo dele.

Etapa 1: Pré-requisitos de instalação

Você precisa do Python 3.14 e do uv (o rápido gerenciador de pacotes Python). No macOS:

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

# Install Python 3.14 via uv
uv python install 3.14

No Windows PowerShell:

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

A razão para uv em vez de pip: é aproximadamente 10-100x mais rápido para resolver dependências, e o pyproject.toml do repositório proxy está configurado para isso. Você pode usar pip se insistir, mas uv torna a instalação instantânea.

Etapa 2: clonar o repositório

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

Essa etapa .env.example → .env é onde a maioria das pessoas tropeça. O arquivo .env fica oculto por padrão no macOS. Se você não conseguir vê-lo no Finder, pressione Cmd+Shift+. (ponto final) para alternar os arquivos ocultos. No terminal, ls -la mostra isso. No VS Code, isso é exibido por padrão. Isso parece trivial, mas perdi dez minutos na primeira vez me perguntando por que minhas edições não estavam funcionando - eu estava editando um arquivo em um diretório diferente.

Etapa 3: Obtenha suas chaves API

Escolha um back-end. Você pode configurar todos os três posteriormente, mas comece com um para confirmar se o proxy funciona.

OpenRouter: Cadastre-se em openrouter.ai, adicione US$ 5 de crédito (vai durar semanas) e pegue um API key no painel. Cinco dólares em OpenRouter são suficientes para construir vários aplicativos completos por meio do DeepSeek V4 Flash.

NVIDIA NIM: Cadastre-se em build.nvidia.com, junte-se ao NVIDIA Developer Program (gratuito) e gere um API key. Você ganha 1.000 créditos grátis imediatamente. Não é necessário cartão de crédito.

Ollama: Instale em ollama.com e, em seguida, extraia um modelo. Para codificação em um MacBook com 16-32 GB de RAM, comece com ollama pull gemma4:e4b. Para uma estação de trabalho com GPU sério, ollama pull llama4:70b. Não é necessário API key — Ollama é executado localmente.

Etapa 4: Editar `.env`

Abra .env no editor de sua preferência. O arquivo possui blocos comentados para cada back-end. Você descomenta o que deseja e preenche a chave e o nome do modelo. Aqui está uma configuração OpenRouter funcional:

# Backend selection
PROVIDER=openrouter

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

# Proxy port
PORT=8082

Para NVIDIA NIM, troque para:

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

Para Ollama (sem necessidade de chave):

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

Etapa 5: iniciar o proxy

No diretório do repositório:

uv run main.py

Você deverá ver algo como Uvicorn running on http://0.0.0.0:8082. Deixe este terminal aberto — o proxy precisa continuar funcionando enquanto você usa o Claude Code.

Etapa 6: Aponte Claude Code no proxy

Em um novo terminal, defina a variável de ambiente que informa ao Claude Code para onde enviar solicitações e, em seguida, inicie:

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

O valor ANTHROPIC_API_KEY não importa — o proxy o ignora e usa a chave real de .env para autenticar com o backend real. Mas Claude Code se recusa a iniciar sem algum valor nessa variável, então defina-o como algo que não esteja vazio.

Se você quiser que este seja o padrão para um projeto, solte essas exportações em um arquivo .envrc (com direnv) ou em um script de inicialização local do projeto. Eu mantenho um alias de shell claude-cheap que exporta vars e inicia Claude Code de uma só vez.

Essa é toda a configuração. Seis passos, talvez dez minutos se você se mover com cuidado. A primeira vez que analisei, demorei cerca de vinte - a maior parte disso foi a confusão oculta do arquivo .env e um nome de modelo errado na configuração OpenRouter que retornou um 404 confuso.

Se você seguiu algum dos meus outros [guias de fluxo de trabalho Claude Code] (https://www.mejba.me/claude-code-32-power-user-hacks), este é o mesmo Claude Code que você já usa - cada comando, cada comando de barra, cada habilidade. A única diferença é qual modelo está fazendo a inferência nos bastidores.

Como foi realmente construir o Habitual

Quero falar sobre a construção real, não porque o aplicativo seja importante, mas porque as arestas só aparecem quando você avança em um projeto real. Habitual é um rastreador de hábitos – check-ins diários, contagem de sequências, um mapa de calor de calendário, o material padrão. Veja como foi em cada back-end.

DeepSeek V4 Flash através de OpenRouter

Este foi o burro de carga. Comecei com um prompt de um parágrafo: "Crie um rastreador de hábitos mínimo, usuário único, aplicativo da web, Tailwind, vanilla JS, check-in diário com contador de sequências e uma grade de calendário de 30 dias." Claude Code (executando através do proxy em DeepSeek V4 Flash) planejou a estrutura, criou o scaffold dos arquivos, escreveu o HTML e o JavaScript e os executou.

A primeira iteração foi difícil – a lógica de sequência estava errada e a grade do calendário tinha um bug UTC versus horário local. Eu pedi para consertar os dois. Isso os consertou. Pedi para adicionar uma opção de “pular dia” que não quebrasse a seqüência (dias de descanso para hábitos sustentáveis). Ele refatorou o cálculo de sequência de forma limpa.

Três iterações depois, aplicativo funcionando. Gasto total de tokens: 850.000 tokens, divididos aproximadamente igualmente entre entrada e saída. Custo total: cerca de US$ 0,21. A qualidade da saída estava visivelmente abaixo do que Opus 4.7 produziria - os nomes das variáveis eram um pouco genéricos, os comentários eram mais esparsos, o tratamento de erros era mínimo - mas para um projeto paralelo em que vou refatorar tudo o que mantenho, tudo bem.

O único lugar onde o DeepSeek V4 Flash teve dificuldades visíveis foi quando solicitei que ele adicionasse a persistência do IndexedDB com a lógica de migração adequada. Opus 4.7 teria escrito o esquema, o executor de migração e o tratamento de versão em uma única passagem. DeepSeek escreveu o esquema corretamente, perdeu totalmente a migração e tive que perguntar duas vezes antes de implementar algo que sobreviveria a uma mudança de esquema. Para a maior parte do trabalho CRUD, a lacuna é invisível. Para qualquer coisa que exija um pensamento sistêmico cuidadoso, você sentirá a diferença.

GLM-5 através de NVIDIA NIM

Depois que o aplicativo funcionou, reconstruí o mesmo projeto do zero em NIM com GLM-5 para comparar. GLM-5 é, no papel, um modelo muito maior do que DeepSeek V4 Flash – parâmetros MoE de 744B versus a variante flash menor do DeepSeek. E a qualidade da saída mostrou isso. Os nomes das variáveis eram melhores. Os comentários foram mais atenciosos. A implementação do IndexedDB estava correta na primeira passagem.

A compensação foi a velocidade. Cada chamada de ferramenta demorou visivelmente mais tempo – de 4 a 8 segundos versus 2 a 3 no OpenRouter. Para um fluxo de trabalho agentic com mais de 40 chamadas de ferramentas em uma sessão, isso aumenta. A construção completa demorou aproximadamente o dobro do tempo, embora o modelo precisasse de menos idas e vindas porque o resultado era de maior qualidade na primeira vez.

NIM também é gratuito no nível de crédito do desenvolvedor, o que torna a compensação de velocidade mais fácil de aceitar. Se eu fosse fazer inferência de peso aberto de nível de produção, GLM-5 em NIM seria meu padrão. Para iteração rápida em projetos paralelos descartáveis, o OpenRouter vence apenas na capacidade de resposta.

Gemma 4 12B através de Ollama

Foi aqui que as compensações ficaram evidentes. No meu MacBook com 32 GB de memória unificada, o Gemma 4 12B carregou bem e executou pequenas coisas – edições de arquivo único, refatorações simples, nomenclatura de coisas – a aproximadamente 30-40 tokens por segundo. Genuinamente utilizável.

No momento em que Claude Code tentou carregar quatro ou cinco arquivos no contexto para uma refatoração de vários arquivos, as coisas falharam. A transmissão diminuiu drasticamente. As chamadas de ferramentas começaram a expirar. Um deles truncou silenciosamente a resposta intermediária, que é o modo de falha que o proxy não pode corrigir totalmente - Ollama apenas retorna menos do que deveria e Claude Code pensa que a tarefa está concluída.

Especificamente para Habitual, Gemma 4 12B passou pelo andaime inicial, mas não conseguiu lidar com o refatorador de lógica de sequência sem que eu o alimentasse manualmente, um arquivo por vez. Em uma estação de trabalho com 4090, isso não seria problema. Em um MacBook sem um GPU discreto, trate o Ollama local como uma ferramenta para tarefas curtas e focadas, em vez de um driver diário Claude Code.

Há uma conversa mais profunda sobre o desenvolvimento local do AI que vale a pena ter - falei mais sobre isso em [minha postagem de configuração local do Gemma 4] (https://www.mejba.me/gemma-chat-offline-vibe-coding-mac) - mas a versão resumida é: Apple Silicon é genuinamente impressionante para inferência local e ainda não é um substituto para modelos de camada de nuvem em fluxos de trabalho de codificação agentic.

O verdadeiro movimento poderoso: orquestração multimodelo

É aqui que isso fica interessante além de economizar dinheiro. Depois de ter um proxy que pode rotear para diferentes modelos, você estará a um passo do padrão de orquestração que está silenciosamente se tornando o padrão para o desenvolvimento sério do AI.

A ideia: usar o Opus 4.6 (ou 4.7) em sua assinatura paga do Anthropic como planejador e orquestrador. Faça com que ele divida uma tarefa complexa em subtarefas distintas. Em seguida, delegue cada subtarefa a um modelo barato – DeepSeek V4 Flash, GLM-5, qualquer que seja – por meio do proxy. A Opus analisa os resultados, integra-os e apenas queima seu caro contexto no pensamento de alta alavancagem.

Na prática, isso parece executar duas instâncias Claude Code lado a lado. Uma é a sua sessão principal no Anthropic-direct, fazendo a orquestração e as decisões arquitetônicas. A outra é a sessão proxy rodando em um backend barato, executando o trabalho de implementação de rotina – gerar o arquivo de teste, escrever o padrão, atualizar os documentos, refatorar esta função. Você distribui subtarefas da primeira para a segunda e depois volta à primeira para integrar.

Venho fazendo variações disso há alguns meses. A matemática do token torna-se atraente rapidamente. Um dia típico em que eu poderia queimar 3-4 milhões de tokens de Opus por assinatura torna-se talvez 800K de Opus (o planejamento, a integração, as partes difíceis) e 3 milhões de DeepSeek por meio do proxy (a execução, o clichê, os refatoradores de rotina). A qualidade da saída é indistinguível no produto acabado. O tempo gasto é semelhante. A diferença de custo é dramática.

Esse padrão ecoa o que abordei no [guia do SDK agent do Anthropic] (https://www.mejba.me/anthropic-agent-sdk-guide) - o futuro da codificação agentic não é "um modelo gigante faz tudo", é "um bom modelo orquestra muitos modelos baratos". O proxy é a peça que falta para tornar isso prático sem escrever código de orquestração personalizado.

O que esta abordagem dá errado (a parte honesta)

Eu estaria mentindo se dissesse que este é um substituto imediato para o Claude Code pago. Existem limitações reais e você deve conhecê-las antes de submeter um projeto real a esta pilha.

Modelos baratos perdem detalhes nas bordas de tarefas complexas. Mencionei isso com a migração do IndexedDB. Ele aparece principalmente em: raciocínio async/concurrency complexo, implicações sutis de segurança, refatorações profundas que afetam muitos arquivos ao mesmo tempo e qualquer coisa que exija uma forte compreensão das compensações arquitetônicas. Em 70-80% do trabalho típico de codificação, você não notará. Para os difíceis 20%, você sentirá a diferença.

Alguns recursos do Claude Code assumem Anthropic-direct. O modo rápido (o novo nível de baixa latência no Claude Code 2.x) apresenta erros em back-ends não Anthropic porque depende de otimizações de streaming específicas do Anthropic. Algumas habilidades e plugins que usam formatos de uso de ferramentas específicos do Claude podem se comportar de maneira estranha. A maioria dos recursos principais – edição de arquivos, sub-agents, comandos de barra, sistema de habilidades – funcionam bem. Casos extremos vão te atrapalhar.

Sessões longas degradam-se mais rapidamente em modelos baratos do que no Opus. Descobri que cerca de 50.000 tokens em uma sessão, a qualidade de saída no DeepSeek V4 Flash começa a cair visivelmente. O modelo perde o controle das decisões anteriores, se contradiz e começa a alucinar assinaturas de funções anteriores na conversa. A correção é mecânica: quando você atingir aquela parede, saia do Claude Code, reinicie com um novo contexto e recarregue os arquivos relevantes. Na janela de contexto de 1M do Opus 4.7, isso raramente é necessário até uma sessão muito mais profunda.

Modelos locais em um MacBook sem um GPU são genuinamente lentos. Abordei isso na seção Ollama, mas vale a pena repetir. Trate Ollama-on-MacBook como uma ferramenta de privacidade, não como uma ferramenta de produtividade. Para um desempenho real de inferência local, você precisa do hardware NVIDIA GPU.

Mudança na privacidade e no fluxo de dados. Quando você roteia por OpenRouter ou NIM, seus prompts e código passam pela infraestrutura deles. OpenRouter tem políticas de privacidade razoáveis e não treina seus dados por padrão, mas é um salto adicional e uma empresa adicional para ver seu código. Para trabalho de cliente, trabalho de NDA ou qualquer coisa sensível: permaneça em Anthropic-direct ou use Ollama-local completo. Sem meio termo.

A economia de assinatura tem um limite máximo. Se você já está pagando pelo Max (US$ 100-200/month), você não vai economizar a assinatura inteira encaminhando projetos pessoais por meio do proxy — você ainda vai querer o Max para o trabalho do cliente e de produção. A economia aparece como “Não vou mais comprar créditos API além da minha assinatura para experimentos pessoais”, o que é real, mas limitado.

A linha de modelos também está avançando rapidamente. Os nomes nesta postagem – DeepSeek V4 Flash, GLM-5, GLM-5.1, Gemma 4 – eram atuais em maio de 2026. No momento em que você ler isto, pode haver carros-chefe mais novos com preços mais baixos. Verifique a página de preços do OpenRouter e o catálogo de modelos NVIDIA NIM antes de se comprometer com um modelo específico em seu .env.

O que eu diria a alguém a partir de hoje

Se você está pensando em tentar isso, aqui está o caminho que eu seguiria se estivesse começando de novo.

Gaste dez minutos na configuração do OpenRouter com DeepSeek V4 Flash. Deixe $ 5 em crédito. Coloque o proxy em execução. Crie algo pequeno – um script, um aplicativo minúsculo, qualquer coisa que você gastaria alguns minutos de cota de assinatura. Observe como é a sensação. O atrito é quase zero e o custo é quase zero.

Se essa experiência fisgou você (me fisgou), configure NVIDIA NIM como seu segundo back-end. O nível gratuito com GLM-5 é genuinamente bom e oferece um substituto de maior qualidade quando DeepSeek V4 Flash não é suficiente. A troca de backends é uma linha em .env e uma reinicialização do proxy.

Não se preocupe com o Ollama, a menos que você tenha uma estação de trabalho com um GPU real ou precise especificamente de privacidade apenas local. Em um MacBook, a experiência irá decepcioná-lo e essa é a primeira impressão errada para o que de outra forma seria um ótimo conjunto de ferramentas.

Quando estiver confortável, experimente o padrão de orquestração. Execute o Opus em Anthropic-direct para planejamento e arquitetura. Execute o DeepSeek por meio do proxy para execução. A economia de custos aumenta rapidamente e o fluxo de trabalho parece surpreendentemente natural depois de alguns dias.

E continue pagando a Max pelo trabalho que importa. Essa abordagem de proxy não substitui o que o Anthropic cobra de você - confiabilidade, suporte, o melhor modelo absoluto da categoria para problemas difíceis. É uma maneira de estender seu orçamento de experimentação em uma ordem de grandeza sem abrir mão da interface Claude Code que você já adora.

O aplicativo Habitual ainda está no meu telefone. Eu verifico todas as manhãs. Custou-me 23 centavos para construir, funciona inteiramente no meu navegador e eu realmente o uso. Se na próxima semana eu quiser adicionar categorias de hábitos, relatórios semanais ou um sistema de notificação, acionarei o proxy, apontarei Claude Code para OpenRouter e iterarei por mais um punhado de centavos. Esse é o desbloqueio.

O resto de 2026 será um passeio selvagem para as ferramentas AI. Os modelos estão ficando mais baratos. As opções de peso aberto estão alcançando os modelos de fronteira fechada mais rapidamente do que se previa. A abordagem de proxy é a forma certa para este momento – mantenha a melhor UX, direcione para qualquer modelo que faça sentido para a tarefa e deixe o mercado de inferência fazer o seu trabalho.

Construa o projeto paralelo. Construa-o através do proxy. Gaste o dólar que você economizou em café.

Perguntas frequentes

Quanto custa executar o Claude Code por meio do Claude Code proxy gratuito?

Para a maioria dos projetos pessoais, os custos variam de totalmente gratuitos (créditos NVIDIA NIM ou Ollama local) a menos de US$ 1 por criação de aplicativo (DeepSeek V4 Flash em OpenRouter com tokens de entrada de US$ 0,14/M). O mesmo projeto em Anthropic direto API custaria entre US$ 5 e US$ 10. A configuração é gratuita; seu único gasto é a inferência em qualquer back-end que você escolher.

O proxy funciona com todos os recursos do Claude Code?

A maioria dos recursos funciona – edição de arquivos, sub-agents, comandos de barra, habilidades, MCP servers, fluxos de trabalho de vários arquivos. A exceção notável é o modo rápido, que depende de otimizações de streaming específicas do Anthropic e erros em back-ends não Anthropic. Alguns plug-ins que usam formatos de uso de ferramentas específicos do Anthropic também podem se comportar de maneira estranha. Consulte o passo a passo de implementação acima para obter a configuração completa.

É seguro enviar meu código através de OpenRouter ou NVIDIA NIM?

Para projetos pessoais e trabalhos de código aberto, ambos os provedores têm políticas de privacidade razoáveis e não treinam com base nos seus dados por padrão. Para trabalho de cliente, código vinculado a NDA ou qualquer coisa com credenciais, permaneça em Anthropic-direct ou use Ollama localmente – seu código nunca sai de sua máquina com Ollama. Não existe meio-termo seguro para trabalhos delicados.

Qual o melhor modelo gratuito para usar com o proxy?

Para codificação, GLM-5 em NVIDIA NIM é a opção gratuita mais forte – parâmetros 744B, qualidade de classe de fronteira, gratuita com inscrição de desenvolvedor. DeepSeek V4 Flash em OpenRouter é o mais barato com tokens de entrada de $ 0,14/M (não gratuito, mas próximo) e é mais rápido que NIM. Somente para local, Gemma 4 E4B em Ollama funciona em Apple Silicon, mas tem limites de hardware.

Posso alternar entre backends sem reinstalar?

Sim. Altere o valor PROVIDER em seu arquivo .env, reinicie o proxy com uv run main.py e Claude Code usará o novo back-end em sua próxima solicitação. Você não precisa reiniciar o próprio Claude Code. Muitos usuários mantêm vários arquivos .env (.env.openrouter, .env.nim, .env.ollama) e vinculam simbolicamente o arquivo ativo.

Vamos trabalhar juntos

Procurando construir sistemas AI, automatizar fluxos de trabalho ou dimensionar sua infraestrutura tecnológica? Eu adoraria ajudar.

Fiverr (compilações e integrações personalizadas): fiverr.com/s/EgxYmWD
Portfólio: mejba.me
Ramlit Limited (soluções empresariais): ramlit.com
ColorPark (design e marca): colorpark.io
xCyberSecurity (serviços de segurança): xcybersecurity.io