---
title: "Claude Code com DeepSeek, GLM ou qualquer API OpenAI"
description: "O Claude Code fala a Messages API da Anthropic. Como rodá-lo com modelos abertos por um proxy LiteLLM ou um endpoint nativo, e o que quebra no caminho."
url: https://broadrouter.com/pt/blog/claude-code-with-openai-compatible-models/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/claude-code-with-openai-compatible-models/) (atualizado em 2026-11-15).

# Claude Code com modelos abertos: proxies, endpoints nativos e limites

Pela equipe da BroadNet Inference · 6 min de leitura · Publicado em 2026-11-15

O Claude Code envia requisições no formato Messages API da Anthropic para o ANTHROPIC\_BASE\_URL. Para usar um provedor compatível com a OpenAI, rode um proxy tradutor como o LiteLLM e aponte o Claude Code para ele, ou escolha um provedor com endpoint próprio no formato Anthropic, como DeepSeek ou Z.ai. A Anthropic não dá suporte a modelos não Claude no Claude Code, então teste você mesmo ferramentas, cache e limites de contexto.

## Pontos principais

-   O Claude Code chama /v1/messages no formato Anthropic. Uma API compatível com a OpenAI precisa de um proxy tradutor no meio; o LiteLLM documenta essa configuração.
-   DeepSeek e Z.ai publicam base URLs no formato Anthropic, então o Claude Code pode chamá-las sem proxy.
-   A documentação da Anthropic diz que ela não dá suporte a rotear o Claude Code para modelos não Claude por nenhum gateway. Os testes ficam por sua conta.
-   Na BroadNet, o tool calling está documentado só para GLM 5.3 e Qwen3.8 27B. O Claude Code depende de ferramentas, então use um desses dois.
-   Agentes que aceitam direto uma base URL compatível com a OpenAI, como opencode, Cline e Aider, não precisam de proxy e são mais simples.

**Nesta página**

1.  Por que o Claude Code não chama uma API compatível com a OpenAI diretamente?
2.  Quais são as suas três opções?
3.  Como rodar o Claude Code pelo LiteLLM?
4.  Quais endpoints da DeepSeek e do GLM funcionam sem proxy?
5.  O que quebra ou muda com um modelo não Claude?
6.  Qual modelo da BroadNet colocar por trás do Claude Code?
7.  Dá para usar o plano de preço fixo da BroadNet com o Claude Code?
8.  Quando outro agente é a melhor escolha?
9.  Onde a BroadNet Inference se encaixa

O Claude Code envia toda requisição no formato Messages API da Anthropic, para `/v1/messages` no endereço que `ANTHROPIC_BASE_URL` indicar. A maioria dos provedores de modelos abertos, inclusive a BroadNet Inference, fala o formato OpenAI. Então você precisa de um proxy que traduza entre os dois ou de um provedor que publique um endpoint próprio no formato Anthropic. Este post cobre os dois caminhos, além dos limites que decidem se vale a pena.

## Por que o Claude Code não chama uma API compatível com a OpenAI diretamente?

O guia de compatibilidade de gateways do Claude Code lista os formatos que um gateway precisa expor. Para uma base URL simples, é o Anthropic Messages: `/v1/messages`, com `/v1/messages/count_tokens` opcional, e os headers `anthropic-beta` e `anthropic-version` repassados. Uma [API compatível com a OpenAI](https://broadrouter.com/pt/glossary/openai-compatible-api/) serve `/v1/chat/completions`, com formato de requisição e resposta diferente. Aponte o Claude Code direto para ela e as requisições falham.

Mais uma coisa antes de começar. A própria documentação do Claude Code diz que a Anthropic “doesn’t support routing Claude Code to non-Claude models through any gateway” (tradução: não dá suporte a rotear o Claude Code para modelos não Claude por nenhum gateway). Muita gente faz mesmo assim, mas ninguém na Anthropic vai depurar isso para você.

## Quais são as suas três opções?

| Caminho | Como funciona | Melhor para | Contrapartida |
| --- | --- | --- | --- |
| Proxy tradutor (LiteLLM) | O Claude Code fala formato Anthropic com um proxy local; o proxy chama o provedor compatível com a OpenAI | Usar um provedor compatível com a OpenAI específico, como a BroadNet | Mais um processo para rodar e atualizar; lacunas de tradução |
| Endpoint nativo no formato Anthropic | O próprio provedor aceita `/v1/messages` | Modelos DeepSeek ou GLM direto dos criadores | Cada um mapeia ou ignora alguns campos |
| Outro agente | Use um agente que aceite uma base URL compatível com a OpenAI | Quem não precisa especificamente do Claude Code | Você abre mão da interface e dos recursos do Claude Code |

## Como rodar o Claude Code pelo LiteLLM?

O tutorial do LiteLLM para modelos que não são da Anthropic funciona assim: instale o proxy, defina os modelos em `config.yaml`, inicie-o e depois defina duas variáveis no Claude Code. O LiteLLM traduz entre os formatos, então o Claude Code continua enviando requisições Anthropic.

Defina os modelos da BroadNet do mesmo jeito que no [guia do LiteLLM](https://broadrouter.com/pt/guides/litellm-proxy-custom-provider/), com o prefixo `openai/` e `api_base`:

```yaml
model_list:
  - model_name: glm
    litellm_params:
      model: openai/broadnet/glm-5.3
      api_base: https://inference.broadnet.ai/v1
      api_key: os.environ/BROADNET_API_KEY
      rpm: 30
  - model_name: qwen
    litellm_params:
      model: openai/broadnet/qwen3.8-27b
      api_base: https://inference.broadnet.ai/v1
      api_key: os.environ/BROADNET_API_KEY
      rpm: 30

general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
```

Inicie o proxy:

```bash
uv tool install 'litellm[proxy]'
export BROADNET_API_KEY='your-broadnet-key'
export LITELLM_MASTER_KEY='sk-any-local-secret'
litellm --config config.yaml   # listens on http://0.0.0.0:4000
```

Depois aponte o Claude Code para ele. O `ANTHROPIC_AUTH_TOKEN` sai como header `Authorization: Bearer`, que é o que o LiteLLM lê:

```bash
export ANTHROPIC_BASE_URL=http://0.0.0.0:4000
export ANTHROPIC_AUTH_TOKEN="$LITELLM_MASTER_KEY"
export ANTHROPIC_MODEL=glm                  # main model
export ANTHROPIC_DEFAULT_HAIKU_MODEL=qwen   # background tasks
export ANTHROPIC_DEFAULT_SONNET_MODEL=glm   # the sonnet alias
export ANTHROPIC_DEFAULT_OPUS_MODEL=glm     # the opus alias
export CLAUDE_CODE_SUBAGENT_MODEL=glm       # subagents
claude
```

Rode `/status` no Claude Code. A linha `Anthropic base URL` deve mostrar o endereço do proxy.

As variáveis de modelo importam. A página do LiteLLM sobre o Claude Code avisa que escolher um nome interno do Claude que a sua configuração não define falha com “Invalid model name passed in” (tradução: nome de modelo inválido). A referência de variáveis de ambiente do Claude Code diz que `ANTHROPIC_DEFAULT_HAIKU_MODEL` também é usado em funções de segundo plano, então mapeie-o também, senão as requisições de segundo plano pedem um nome Haiku que o proxy não conhece. `CLAUDE_CODE_SUBAGENT_MODEL` define o modelo padrão dos subagentes, mas o modelo que o Claude passa ao criar um, muitas vezes um alias como `sonnet` ou `haiku`, tem precedência. Mapear também os aliases `sonnet` e `opus` faz essas requisições caírem num modelo que o proxy conhece. Guarde a sua chave da BroadNet no ambiente do proxy, nunca num `.claude/settings.json` de projeto que vai para o repositório.

## Quais endpoints da DeepSeek e do GLM funcionam sem proxy?

Dois criadores de modelos publicam base URLs no formato Anthropic:

| Provedor | Base URL | Tratamento dos modelos (pela documentação deles, conferida em 2026-11-15) |
| --- | --- | --- |
| DeepSeek | `https://api.deepseek.com/anthropic` | Nomes `claude-sonnet*` e `claude-haiku*` são mapeados para `deepseek-flash`; `claude-opus*` para `deepseek-v4-pro`; nomes que não começam com `claude` retornam 400 |
| Z.ai (GLM Coding Plan) | `https://api.z.ai/api/anthropic` | Chave em `ANTHROPIC_AUTH_TOKEN`; o exemplo de configuração manual mapeia Opus e Sonnet para `glm-5.3[1m]` e Haiku para `glm-5.3-flash[1m]` |

A nota de lançamento da DeepSeek de 10 de setembro de 2026 diz que `deepseek-flash` serve o DeepSeek-V4.1-Flash. A página da Anthropic API dela também lista o que é ignorado: `cache_control`, `budget_tokens`, `disable_parallel_tool_use` e o header `anthropic-version`, entre outros. No `deepseek-flash`, imagens em mensagens do assistente retornam 400, e o `deepseek-v4-pro` troca as imagens por “\[Unsupported Image\]”.

Se você só quer DeepSeek ou GLM no Claude Code, esses endpoints nativos são o caminho mais curto. Preços e limites de plano dos dois estão comparados na [página de alternativas à API do Claude](https://broadrouter.com/alternatives/anthropic-api-alternative/).

## O que quebra ou muda com um modelo não Claude?

A tradução mantém as requisições fluindo, mas vários recursos do Claude Code dependem de coisas que um proxy ou outro modelo podem não repassar. A documentação do Claude Code cita estes:

-   **Prompt caching.** O Claude Code marca os blocos `system` e de mensagens com `cache_control`. Se o gateway ou o serviço upstream descartar isso, não há erro, mas cada turno é cobrado como entrada sem cache. Num upstream compatível com a OpenAI, o cache segue as regras daquele provedor. A BroadNet cobra a [entrada em cache](https://broadrouter.com/pt/glossary/cached-input-tokens/) por um preço menor quando o bloco usage dela informa um cache hit; confira `cached_tokens` nos seus logs.
-   **Contagem de tokens.** Sem `/v1/messages/count_tokens`, o Claude Code recorre a uma estimativa por caracteres, então o `/context` é aproximado.
-   **Janela de contexto.** O Claude Code aplica a própria janela padrão a nomes de modelo que não reconhece. Defina `CLAUDE_CODE_AUTO_COMPACT_WINDOW` (de 100.000 a 1.000.000 de tokens) de acordo com o modelo. Para o Qwen3.8 27B, com contexto de 262.144 tokens, defina bem abaixo disso.
-   **Campos desconhecidos.** Um `400` citando `Extra inputs are not permitted` ou um valor de `anthropic-beta` significa que algo no upstream rejeitou um campo de pré-lançamento. A documentação sugere `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1`.
-   **Raciocínio.** `MAX_THINKING_TOKENS` e o adaptive thinking são recursos do Claude. Na BroadNet, DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B raciocinam antes de responder, e esses [tokens de raciocínio](https://broadrouter.com/pt/glossary/reasoning-tokens/) contam no `max_tokens`. Se as respostas voltarem vazias, aumente o limite de saída ou envie `reasoning_effort` baixo. Veja [por que modelos de raciocínio devolvem respostas vazias](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).
-   **Imagens.** Na BroadNet, o GLM 5.3 aceita só texto. Use o Qwen3.8 27B se você cola capturas de tela.

Teste uma tarefa real de ponta a ponta, com edição de arquivos, comandos de shell e uma sessão longa, antes de depender disso.

## Qual modelo da BroadNet colocar por trás do Claude Code?

O Claude Code lê arquivos, edita e roda comandos por meio de [chamadas de ferramenta](https://broadrouter.com/pt/glossary/tool-calling/). A referência da API da BroadNet documenta ferramentas, saída estruturada e raciocínio para dois modelos:

| Modelo | Entrada / saída por 1M de tokens | Contexto | Imagens | Ferramentas documentadas |
| --- | --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) | $0.78 / $3.46 | 1.048.576 | Não | Sim |
| [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) | $0.175 / $2.17 | 262.144 | Sim | Sim |
| [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) | $0.175 / $0.52 | 1.048.576 | Sim | Não documentadas |

O GLM 5.3 é o modelo principal natural para repositórios grandes. O Qwen3.8 27B custa menos por token de entrada e serve para imagens e chamadas de segundo plano mais leves. Os dois exigem uma recarga; não são cobertos pelo crédito inicial de $5. A [comparação entre GLM 5.3 e Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/) mostra os dois lado a lado.

## Dá para usar o plano de preço fixo da BroadNet com o Claude Code?

Não como uso documentado, e é melhor saber disso antes de comprar. Os planos Full Moon, Orbit e Meteor cobrem só o DeepSeek V4.1 Flash, e a BroadNet não documenta tool calling para ele. Cada [sessão do plano](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/) também roda uma requisição por vez. O Claude Code pode rodar subagentes e tarefas de segundo plano junto com o loop principal, e essas requisições ficariam na fila de uma única sessão.

Se o que você quer é preço fixo, use um agente que a BroadNet documenta com o plano, como o [Aider](https://broadrouter.com/pt/guides/aider-unlimited-deepseek/). Para o Claude Code, use GLM 5.3 ou Qwen3.8 27B com pagamento por uso, que permitem 30 requisições por minuto e 4 em andamento por chave. Faça backoff nos 429 como em [erros e novas tentativas](https://broadrouter.com/pt/guides/errors-and-retries/).

## Quando outro agente é a melhor escolha?

Se você não precisa do Claude Code em si, pule o proxy. opencode, Cline, Roo Code, Continue e Aider aceitam diretamente uma base URL compatível com a OpenAI, uma chave e um ID de modelo. Os nomes dos campos de cada um estão em [modelos abertos em agentes de código](https://broadrouter.com/pt/blog/use-open-models-in-coding-agents/), com guias de configuração para o [opencode](https://broadrouter.com/pt/guides/opencode-custom-provider/) e o [Cline](https://broadrouter.com/pt/guides/cline-openai-compatible/). Menos peças móveis significa menos bugs de tradução. Para comparar modelos para esse trabalho, veja [melhor modelo aberto para agentes de código](https://broadrouter.com/pt/blog/best-open-model-for-coding-agents/).

Fique nos modelos Claude se o seu trabalho depende de recursos específicos do Claude, como extended thinking, o prompt caching da Anthropic ou as betas mais novas do Claude Code. Nesse caso, [reduza os custos dentro do Claude Code](https://broadrouter.com/pt/blog/cut-coding-agent-llm-costs/) em vez de trocar o modelo.

## Onde a BroadNet Inference se encaixa

A BroadNet Inference é uma API compatível com a OpenAI, então só chega ao Claude Code por meio de um proxy como o LiteLLM. Por trás de um proxy, GLM 5.3 e Qwen3.8 27B são os dois modelos com tool calling documentado, cobrados por token e sem conteúdo retido depois da requisição. Se você quer um endpoint nativo no formato Anthropic, DeepSeek e Z.ai são mais simples. Se você quer o plano de preço fixo da BroadNet, combine-o com um agente que fale o formato OpenAI.

Ferramentas gratuitas sobre o tema (em inglês)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Base URL (URL base)](https://broadrouter.com/pt/glossary/base-url/)

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[API compatível com a OpenAI](https://broadrouter.com/pt/glossary/openai-compatible-api/)

Uma API compatível com a OpenAI é uma API HTTP que aceita os mesmos formatos de requisição e de resposta da API da OpenAI, como POST /v1/chat/completions, de modo que SDKs e ferramentas da OpenAI podem usá-la trocando só a base URL, a chave de API e o nome do modelo.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

[Tokens de entrada em cache (cached input)](https://broadrouter.com/pt/glossary/cached-input-tokens/)

Tokens de entrada em cache são tokens do prompt que um provedor de LLM processou há pouco e pode reaproveitar de um cache em vez de calcular de novo, normalmente um prefixo repetido, como um system prompt ou um documento. Os provedores os cobram com uma tarifa menor que a dos tokens de entrada novos.

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

[Plano de LLM com preço fixo (flat-rate)](https://broadrouter.com/pt/glossary/flat-rate-llm-plan/)

Um plano de LLM com preço fixo cobra um valor fixo por um período, como um mês, pelo acesso à API de um modelo de linguagem, em vez de cobrar por token. Esses planos costumam limitar outra coisa, como simultaneidade, velocidade, modelos ou janelas de uso, então os limites importam tanto quanto o preço.

## Perguntas frequentes

### O Claude Code pode usar o DeepSeek?

Sim, de duas formas. A DeepSeek publica uma base URL no formato Anthropic, https://api.deepseek.com/anthropic, que mapeia os nomes claude-sonnet e claude-haiku para deepseek-flash e os nomes claude-opus para deepseek-v4-pro. Ou você coloca um proxy tradutor como o LiteLLM na frente de qualquer host compatível com a OpenAI que sirva modelos DeepSeek.

### O Claude Code funciona com uma API compatível com a OpenAI?

Não diretamente. O Claude Code envia requisições da Messages API da Anthropic para /v1/messages. Um proxy como o LiteLLM aceita essas requisições, encaminha para um endpoint /chat/completions no estilo OpenAI e depois traduz a resposta de volta.

### A Anthropic dá suporte ao uso do Claude Code com outros modelos?

Não. A documentação de gateways do Claude Code diz que a Anthropic não dá suporte a rotear o Claude Code para modelos não Claude por nenhum gateway. Na prática funciona para muita gente, mas os bugs nesse caminho você mesmo depura.

### Qual modelo da BroadNet devo usar por trás do Claude Code?

GLM 5.3 ou Qwen3.8 27B. A BroadNet documenta tool calling só para esses dois, e o Claude Code edita arquivos e roda comandos por meio de ferramentas. O GLM 5.3 tem contexto de 1.048.576 tokens; o Qwen3.8 27B tem 262.144 e aceita imagens.

### Posso rodar o Claude Code no plano ilimitado da BroadNet?

Não como uso documentado. Os planos de preço fixo cobrem só o DeepSeek V4.1 Flash, e a BroadNet não documenta tool calling para esse modelo. Além disso, uma sessão do plano roda uma requisição por vez, enquanto o Claude Code pode rodar subagentes em paralelo.

### Por que o Claude Code diz "Invalid model name" pelo LiteLLM?

O Claude Code pediu um nome de modelo que o seu config.yaml não define, muitas vezes um alias interno do Claude ou o modelo Haiku de segundo plano. Defina ANTHROPIC\_MODEL e ANTHROPIC\_DEFAULT\_HAIKU\_MODEL com nomes da sua model\_list.

## Continue lendo

-   [Modelos abertos em agentes de código: Aider, Cline, opencode, Codex](https://broadrouter.com/pt/blog/use-open-models-in-coding-agents/)
-   [Tool calling com modelos abertos: schemas, chamadas paralelas, retry](https://broadrouter.com/pt/blog/tool-calling-open-models/)
-   [Melhor modelo aberto para agentes de código: ferramentas e custo](https://broadrouter.com/pt/blog/best-open-model-for-coding-agents/)
-   [10 formas de reduzir o custo de LLM de agentes de código, com economia](https://broadrouter.com/pt/blog/cut-coding-agent-llm-costs/)
-   [Como rodar agentes de código em paralelo numa API de LLM de preço fixo](https://broadrouter.com/pt/blog/run-parallel-coding-agents-flat-rate/)
-   [Custo de uma execução de agente de código: passos, contexto e cache](https://broadrouter.com/pt/blog/ai-coding-agent-run-cost/)
-   [OpenClaw e Hermes Agent com um modelo barato: setup e custos](https://broadrouter.com/pt/blog/openclaw-hermes-agent-cheap-model/)
-   [Guia: Como rotear o LiteLLM para a BroadNet Inference (SDK e proxy)](https://broadrouter.com/pt/guides/litellm-proxy-custom-provider/)
-   [Guia: Adicionar a BroadNet Inference ao opencode como provedor personalizado](https://broadrouter.com/pt/guides/opencode-custom-provider/)
-   [Guia: Use o Cline com a BroadNet Inference (provedor OpenAI Compatible)](https://broadrouter.com/pt/guides/cline-openai-compatible/)
-   [Guia: Rode o Aider no DeepSeek V4.1 Flash ilimitado](https://broadrouter.com/pt/guides/aider-unlimited-deepseek/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-claude-code-with-openai-compatible-models&utm_content=page-cta) ·

**Fontes**

-   [Documentação do Claude Code, outros gateways de LLM: sem suporte a modelos não Claude (conferida em 2026-11-15)](https://code.claude.com/docs/en/llm-gateway)
-   [Documentação do Claude Code, conectar a um gateway de LLM: ANTHROPIC\_BASE\_URL, ANTHROPIC\_AUTH\_TOKEN, solução de problemas (conferida em 2026-11-15)](https://code.claude.com/docs/en/llm-gateway-connect)
-   [Documentação do Claude Code, guia de compatibilidade de gateways: /v1/messages, repasse de cache\_control (conferida em 2026-11-15)](https://code.claude.com/docs/en/llm-gateway-protocol)
-   [Documentação do Claude Code, variáveis de ambiente (conferida em 2026-11-15)](https://code.claude.com/docs/en/env-vars)
-   [Documentação do LiteLLM, usar o Claude Code com modelos que não são da Anthropic (conferida em 2026-11-15)](https://docs.litellm.ai/docs/tutorials/claude_non_anthropic_models)
-   [Documentação do LiteLLM, configuração do cliente Claude Code: ANTHROPIC\_MODEL e Invalid model name (conferida em 2026-11-15)](https://docs.litellm.ai/docs/proxy/client_setup/claude_code)
-   [Documentação da API da DeepSeek, Anthropic API: base URL, mapeamento de modelos, campos ignorados (conferida em 2026-11-15)](https://api-docs.deepseek.com/guides/anthropic_api)
-   [Notícias da DeepSeek, lançamento do DeepSeek-V4.1-Flash, nome do modelo deepseek-flash (10 de setembro de 2026; conferida em 2026-11-15)](https://api-docs.deepseek.com/news/news260910)
-   [Documentação da Z.ai, GLM Coding Plan no Claude Code (conferida em 2026-11-15)](https://docs.z.ai/devpack/tool/claude)
-   [Referência da API da BroadNet Inference: modelos, ferramentas, raciocínio, limites (conferida em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-claude-code-with-openai-compatible-models&utm_content=sources)
