Ahorra el 90 % en Claude Code: usa OpenRouter, Ollama o LiteLLM

Claude Code se entrega con los modelos de Anthropic, pero una sola variable de entorno -- ANTHROPIC_BASE_URL -- te permite enrutar solicitudes a prácticamente cualquier proveedor LLM. Eso significa que puedes cambiar a DeepSeek a aproximadamente $0,27 por millón de tokens de salida en lugar de Claude Opus a $25, o ejecutar modelos localmente a través de Ollama de forma gratuita. Esta guía cubre todos los métodos para usar diferentes modelos en Claude Code, basándose en nuestra comparación detallada de Claude Code con configuración práctica para cada enfoque.

Todos los métodos de un vistazo

Elige el método que se adapte a tu situación y luego salta a su sección para el código de configuración.

Sigue leyendo para la configuración paso a paso de cada método, o salta directamente al marco de decisión si ya sabes lo que necesitas.

¿Cómo funciona realmente el cambio de modelo en Claude Code?

Antes de configurar cualquier proxy, necesitas entender por qué la mayoría de los tutoriales te dejan con una configuración defectuosa. Claude Code usa internamente tres ranuras de modelo -- no una:

• Ranura Haiku -- tareas en segundo plano como resumen de archivos y completado de pestañas
• Ranura Sonnet -- codificación predeterminada, el modelo con el que más interactúas
• Ranura Opus -- razonamiento complejo, planificación y tareas agénticas de múltiples pasos

Cuando cambias el modelo con /model o --model, solo estás cambiando la ranura principal. Claude Code sigue intentando llamar a las otras dos ranuras usando la API de Anthropic. Si has apuntado ANTHROPIC_BASE_URL a un proxy pero solo has configurado un modelo, esas otras ranuras fallan con un error "model not found".

La solución: configura las tres variables de entorno para que cada ranura pase por tu proxy.

# Configurar las tres ranuras para pasar por tu proxy
export ANTHROPIC_DEFAULT_HAIKU_MODEL="tu-equivalente-haiku"
export ANTHROPIC_DEFAULT_SONNET_MODEL="tu-equivalente-sonnet"
export ANTHROPIC_DEFAULT_OPUS_MODEL="tu-equivalente-opus"

Cambio de modelo nativo (modelos Anthropic)

Si te quedas dentro de la familia de modelos Anthropic, el cambio es sencillo. Usa el comando /model dentro de Claude Code, pasa --model al lanzar desde la terminal, o agrega modelos al arreglo availableModels en tu archivo de configuración. Anthropic sigue añadiendo opciones aquí, y nuestro resumen de las funciones más recientes de Claude Code para 2026 rastrea lo que se ha lanzado recientemente.

La estrategia opusplan

opusplan es el enrutamiento multi-modelo integrado de Claude Code. Envía tareas en segundo plano a Haiku y canaliza el razonamiento complejo a Opus -- automáticamente. No lo configuras manualmente; simplemente selecciónalo como tu modelo. Es la propia respuesta de Anthropic al problema "¿por qué estoy pagando precios Opus por un listado de archivos?". Vale la pena probar antes de recurrir a un enrutador de terceros, junto con el modo rápido de Anthropic si la velocidad pura es tu prioridad.

OpenRouter -- Una clave API, 300+ modelos

OpenRouter actúa como un agregador de API. Obtienes una sola clave API y acceso a 300+ modelos de Anthropic, Google, Meta, Mistral, DeepSeek y más. Los precios son de paso a través para la mayoría de los modelos -- sin recargo.

Pasos de configuración

1. Crea una cuenta en openrouter.ai y genera una clave API
2. Ejecuta claude /logout para borrar cualquier sesión de Anthropic existente
3. Configura tus variables de entorno:

export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_API_KEY="sk-or-v1-tu-clave-aqui"

# Mapear las tres ranuras de modelo
export ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek/deepseek-chat-v3"
export ANTHROPIC_DEFAULT_SONNET_MODEL="anthropic/claude-sonnet-4"
export ANTHROPIC_DEFAULT_OPUS_MODEL="anthropic/claude-opus-4"

1. Lanza claude y verifica la conexión

Nota las tres variables de ranura -- omítelas y obtendrás el error "model not found" que cubrimos arriba. La guía oficial de integración de OpenRouter confirma esta configuración.

Modelos recomendados a través de OpenRouter

No todos los modelos en OpenRouter manejan el tool calling de Claude Code de forma confiable. Esto es lo que realmente funciona bien:

Costos y facturación

OpenRouter cobra precios de paso a través en la mayoría de los modelos. Pagas exactamente lo que cobra el proveedor subyacente, más un pequeño margen en algunos modelos de terceros. Establece límites de gasto en tu panel de OpenRouter para evitar sorpresas.

Veredicto: OpenRouter es la mejor opción para desarrolladores que quieren máxima variedad de modelos con mínima configuración. Una clave API, un panel de facturación, 300+ modelos. Difícil de superar en flexibilidad.

Ollama -- Gratis, local y privado

Ollama ejecuta modelos completamente en tu máquina. Desde la v0.14.0 (enero 2026), admite la API Anthropic Messages de forma nativa, lo que significa que Claude Code puede comunicarse con él sin ninguna capa de traducción. Tu código nunca sale de tu máquina.

Requisitos previos y hardware

Necesitarás hardware decente para una experiencia usable:

• Modelos 7B (ediciones rápidas, tareas simples): 16 GB de RAM como mínimo
• Modelos 14B (buena calidad de codificación): 32 GB de RAM, GPU recomendada
• Modelos 32B+ (calidad casi de nube): 64 GB de RAM o GPU dedicada con 24 GB+ de VRAM

Para un análisis más profundo de los requisitos de hardware y la selección de modelos, consulta nuestra guía para ejecutar LLMs localmente.

Pasos de configuración

1. Instala Ollama desde ollama.com
2. Descarga un modelo enfocado en codificación
3. Lanza con compatibilidad Claude Code
4. Configura tus variables de entorno

# Instalar y descargar un modelo de codificación
ollama pull qwen2.5-coder:14b

# Lanzar con compatibilidad Claude Code
ollama launch claude

# Configurar variables de entorno
export ANTHROPIC_BASE_URL="http://localhost:11434"
export ANTHROPIC_API_KEY="ollama"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="qwen2.5-coder:14b"
export ANTHROPIC_DEFAULT_SONNET_MODEL="qwen2.5-coder:14b"
export ANTHROPIC_DEFAULT_OPUS_MODEL="qwen2.5-coder:14b"

La documentación de integración de Ollama recomienda modelos con ventanas de contexto de 64k+ tokens para la mejor experiencia con Claude Code.

Mejores modelos locales para codificación

Sé honesto contigo mismo sobre una cosa: los modelos locales producen una calidad de código notablemente inferior a Claude Sonnet para tareas agénticas complejas de múltiples pasos. El tool calling es menos confiable y verás más rutas de archivos alucinadas. Son fantásticos para ediciones rápidas, generación simple y trabajo sensible a la privacidad -- simplemente no esperes calidad nativa de Claude en un refactoring de 50 archivos.

Veredicto: Ollama es la mejor opción para trabajo sensible a la privacidad y desarrolladores que quieren uso gratuito e ilimitado. Si tienes el hardware, es difícil argumentar en contra de "cero dólares para siempre."

Ollama Cloud vs OpenRouter: precios y cuándo gana cada uno

Ollama y OpenRouter resuelven el problema del costo desde extremos opuestos. Ollama ejecuta modelos en hardware que tú controlas a costo cero por token, mientras que OpenRouter cobra precios de paso a través en 300+ modelos alojados sin hardware que gestionar. Esta guía configura Ollama localmente, y la misma lógica de costo fijo frente a costo por token se aplica si ejecutas su nivel alojado en su lugar.

Elige Ollama cuando la privacidad, el uso sin conexión o las ediciones rutinarias de alto volumen importen y ya tengas el hardware. Elige OpenRouter cuando quieras variedad de modelos, sin hardware inicial y facturación de pago solo por lo que usas.

LM Studio -- Modelos locales con interfaz gráfica

LM Studio ofrece la misma ejecución de modelos locales que Ollama, pero con una interfaz visual. Puedes navegar por modelos en una GUI, elegir niveles de cuantización con un clic y probar el chat antes de apuntar Claude Code hacia él. Mismos requisitos de hardware que Ollama. Si estás comparando ejecutores, nuestra guía de las mejores herramientas para ejecutar LLMs localmente cubre las ventajas y desventajas.

Configuración

1. Descarga LM Studio e instálalo
2. Busca y descarga un modelo de codificación (Qwen 2.5 Coder, devstral, etc.)
3. Inicia el servidor local desde la interfaz de LM Studio
4. Apunta Claude Code hacia él:

# Apuntar Claude Code al servidor local de LM Studio
export ANTHROPIC_BASE_URL="http://localhost:1234/v1"
export ANTHROPIC_API_KEY="lm-studio"
export ANTHROPIC_DEFAULT_SONNET_MODEL="nombre-de-tu-modelo-cargado"

El blog de LM Studio tiene un tutorial con capturas de pantalla si prefieres guías de configuración visuales.

Veredicto: LM Studio es mejor para desarrolladores que prefieren una GUI sobre la línea de comandos para gestionar modelos locales. Si ya estás cómodo con ollama pull y archivos de configuración, quédate con Ollama. Si quieres navegar por modelos visualmente y ajustar configuraciones con controles deslizantes, LM Studio es tu elección.

claude-code-router -- Enrutamiento inteligente de modelos

claude-code-router es un paquete npm que ejecuta un proxy local entre Claude Code y tus proveedores configurados. Lo que lo hace interesante es el enrutamiento consciente del contexto -- puedes enviar tareas de fondo baratas a DeepSeek, codificación predeterminada a Sonnet y razonamiento complejo a Opus, todo automáticamente.

El proyecto tiene 30k+ estrellas en GitHub y admite OpenRouter, DeepSeek, Gemini, Ollama, Groq, Volcengine y SiliconFlow como proveedores.

Instalación y configuración

npm install -g claude-code-router
claude-code-router init
claude-code-router start

El comando init crea un config.json donde defines tus proveedores y las asignaciones de modelos:

{
  "providers": {
    "openrouter": {
      "apiKey": "sk-or-v1-...",
      "models": {
        "haiku": "deepseek/deepseek-chat-v3",
        "sonnet": "anthropic/claude-sonnet-4",
        "opus": "anthropic/claude-opus-4"
      }
    }
  }
}

Configuración de enrutamiento consciente del contexto

Aquí es donde brilla claude-code-router. Puedes enrutar diferentes tipos de tareas a diferentes modelos según la complejidad. El resumen en segundo plano va a un modelo económico, mientras que la planificación y el trabajo de arquitectura van a tu mejor modelo. El enrutador maneja todas las asignaciones de ranuras de forma transparente.

También puedes mezclar proveedores -- usa Ollama para repositorios sensibles a la privacidad y OpenRouter para todo lo demás, cambiando con el comando /model dentro de Claude Code.

Veredicto: claude-code-router es mejor para usuarios avanzados que quieren control detallado sobre qué modelo maneja cada tipo de tarea. Es la opción más configurable, pero esa flexibilidad viene con más configuración que un simple cambio de ANTHROPIC_BASE_URL.

claude-code-proxy y LiteLLM -- Configuraciones avanzadas

Estos dos métodos sirven diferentes necesidades pero comparten un rasgo: ambos son servidores proxy que traducen entre formatos de API.

claude-code-proxy (Backend Gemini y OpenAI)

claude-code-proxy es una herramienta Python (3,3k estrellas en GitHub) que acepta solicitudes en formato Anthropic de Claude Code y las traduce a formato OpenAI o Gemini a través de LiteLLM bajo el capó. Es el camino más simple para usar específicamente Gemini o modelos GPT con Claude Code.

pip install claude-code-proxy
claude-code-proxy --port 8080

# Luego apunta Claude Code hacia él
export ANTHROPIC_BASE_URL="http://localhost:8080"
export ANTHROPIC_API_KEY="tu-clave-gemini-o-openai"

Si específicamente quieres el contexto de 1M tokens de Gemini para monorepos grandes, este es el camino más directo.

LiteLLM (Proxy universal empresarial)

LiteLLM es un proxy de nivel empresarial que admite 100+ proveedores con balanceo de carga, cadenas de respaldo, limitación de velocidad y registro de auditoría. Es excesivo para un desarrollador individual pero esencial para equipos que necesitan gobernanza en el uso de modelos de IA.

La configuración usa un archivo YAML:

model_list:
  - model_name: claude-sonnet-4-20250514
    litellm_params:
      model: gemini/gemini-2.5-flash
      api_key: os.environ/GEMINI_API_KEY
  - model_name: claude-haiku-3-5-20241022
    litellm_params:
      model: deepseek/deepseek-chat
      api_key: os.environ/DEEPSEEK_API_KEY

# Iniciar el proxy LiteLLM
litellm --config config.yaml --port 4000

# Apuntar Claude Code hacia LiteLLM
export ANTHROPIC_BASE_URL="http://localhost:4000"
export ANTHROPIC_API_KEY="sk-litellm"

Una nota importante de la documentación oficial de Claude Code: "Anthropic no respalda, mantiene ni audita LiteLLM." Úsalo, pero sabe que es una herramienta de la comunidad, no un producto de Anthropic. El tutorial de LiteLLM tiene más ejemplos de configuración avanzada.

Veredicto: Usa claude-code-proxy si quieres específicamente modelos Gemini o OpenAI. Usa LiteLLM si tu equipo necesita balanceo de carga, respaldo y registro de auditoría entre proveedores.

Claude Code Router vs LiteLLM: ¿cuál deberías usar?

Claude Code Router es la opción más simple para desarrolladores individuales que quieren enrutamiento de modelos por tarea, mientras que LiteLLM está construido para equipos que necesitan balanceo de carga, cadenas de respaldo y registro de auditoría. Router se instala vía npm y lee un config.json; LiteLLM ejecuta un proxy empresarial configurado en YAML en 100+ proveedores.

Elige claude-code-router si eres un desarrollador individual que quiere tareas de fondo baratas en DeepSeek y razonamiento complejo en Opus sin mucha configuración. Elige LiteLLM si tu equipo necesita balanceo de carga, limitación de velocidad y registros de auditoría entre proveedores.

¿Estás evaluando otros proxies también? Nuestro resumen de las mejores herramientas de LLM gateway las compara una junto a la otra.

¿Qué cuesta realmente cada método?

Pongamos números reales en esto. Aquí está lo que pagarás por 1 millón de tokens para las combinaciones de modelo/método más comunes:

Datos de precios de la página oficial de precios de Anthropic y OpenRouter. El uso moderado asume ~5-10M tokens/mes para sesiones de codificación diarias.

La brecha de costos es significativa, pero los modelos más baratos producen código de menor calidad -- especialmente para tareas agénticas complejas donde la confiabilidad del tool calling importa. DeepSeek a €1,01/MTok de salida es excelente para ediciones de rutina. Para un refactoring de múltiples archivos donde Claude Code necesita leer, planificar, editar y verificar en 20 archivos? Todavía querrás Sonnet u Opus.

Veredicto: Para ahorro de costos con calidad aceptable, OpenRouter + DeepSeek ofrece la mejor relación. Para cero costo, Ollama es imbatible si tienes el hardware. Para calidad máxima, Anthropic directo sigue siendo el rey.

¿Qué método deberías usar? -- Marco de decisión

Aquí está la sección que cada otro tutorial omite. En lugar de decirte "simplemente usa OpenRouter", emparejemos métodos con necesidades reales:

¿Deberías siquiera cambiar?

Opinión honesta: para la mayoría de los desarrolladores que hacen codificación agéntica compleja -- refactorings de múltiples archivos, planificación de arquitectura, depuración de complicados problemas de concurrencia -- Claude Sonnet vía Anthropic directo sigue siendo la mejor opción. Claude nativo tiene el tool calling más confiable, el mejor entendimiento de su propio flujo de trabajo agéntico y cero latencia de proxy.

El cambio de modelo es una optimización para escenarios específicos:

• Estás quemando tokens en tareas de fondo que no necesitan calidad Sonnet, o sigues alcanzando los límites de uso 2x de Claude
• Necesitas la ventana de contexto de 1M tokens de Gemini para un monorepo masivo
• Tu código no puede salir de tu máquina (gobierno, salud, finanzas)
• Tienes un presupuesto ajustado y la calidad aceptable supera a la calidad perfecta

Si ninguno de esos aplica, opusplan (el enrutamiento integrado de Anthropic) podría ser todo lo que necesitas.

La confiabilidad del tool calling es la métrica de calidad que más importa aquí. La jerarquía es: Claude nativo >> OpenRouter Claude >> DeepSeek/Gemini >> modelos locales. Cuanto más abajo vayas, más verás llamadas de herramientas fallidas, rutas de archivos alucinadas y ediciones incompletas.

Solución de problemas comunes

Error "model not found"

Este es el problema más común. Ocurre cuando configuras ANTHROPIC_BASE_URL pero olvidas mapear las tres ranuras de modelo. Claude Code intenta llamar a Haiku u Opus a través de tu proxy, el proxy no reconoce el nombre del modelo predeterminado de Anthropic y obtienes el error.

# Solución: configurar LAS TRES variables de ranura de modelo
export ANTHROPIC_DEFAULT_HAIKU_MODEL="tu-modelo"
export ANTHROPIC_DEFAULT_SONNET_MODEL="tu-modelo"
export ANTHROPIC_DEFAULT_OPUS_MODEL="tu-modelo"

Conexión rechazada / timeout

Tu proxy no está funcionando, o Claude Code está llegando al puerto equivocado. Verifica que el proceso del proxy esté activo y vuelve a comprobar el puerto en ANTHROPIC_BASE_URL. Los firewalls y las VPN también pueden bloquear las conexiones de localhost.

Fallos de tool calling

El modelo no admite correctamente el formato de uso de herramientas de Anthropic. Síntomas: Claude Code se cuelga, produce llamadas de herramientas vacías o edita los archivos incorrectos. Cambia a un modelo con soporte de tool calling verificado -- Qwen 2.5 Coder y devstral lo manejan mejor entre los modelos locales.

Problemas de streaming

Algunos proxies no manejan correctamente los eventos enviados por el servidor. Las respuestas aparecen todas a la vez en lugar de transmitirse, o se truncan a mitad de respuesta. Asegúrate de que tu versión del proxy esté actualizada y revisa los problemas de GitHub en busca de errores de streaming conocidos.

Ventana de contexto excedida

Los modelos locales a menudo tienen ventanas de contexto de 4K-8K por defecto. Claude Code necesita mucho más que eso para sesiones de codificación reales. Usa modelos con contexto de 32K+, o enruta tareas de contexto largo a Gemini (ventana de 1M) a través de OpenRouter.

Debe cerrar sesión primero para OpenRouter

Si estás cambiando de Anthropic directo a OpenRouter, ejecuta primero claude /logout. Claude Code almacena en caché la autenticación y seguirá intentando usar tu clave de Anthropic incluso después de cambiar la URL base.

# Borrar la autenticación almacenada en caché antes de cambiar de proveedor
claude /logout

FAQ

¿Puedes usar Claude Code con GPT-4 o Gemini?

Sí. claude-code-proxy traduce las solicitudes en formato Anthropic a formato OpenAI o Gemini. También puedes acceder a ambos a través de OpenRouter con una sola clave API. El tool calling puede ser menos confiable que el Claude nativo, especialmente para tareas complejas de múltiples pasos.

¿Cómo uso Claude Code sin una clave API de Anthropic?

Usa Ollama para uso local completamente gratuito -- no se necesita clave API de ningún proveedor. Alternativamente, usa OpenRouter con su formato de clave API. Todavía configuras la variable de entorno ANTHROPIC_API_KEY, pero apunta a la clave de tu proxy (por ejemplo, sk-or-v1-... para OpenRouter, "ollama" para Ollama).

¿Cómo configuro Claude Code con Ollama?

Instala Ollama, descarga un modelo como qwen2.5-coder:14b, ejecuta ollama launch claude y configura tres variables de entorno: ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY y las tres variables de ranura de modelo. Consulta la sección de Ollama arriba para el código completo.

¿Qué modelos funcionan mejor con Claude Code?

Para la nube: Claude Sonnet 4 ofrece la mejor calidad de codificación, mientras que DeepSeek V3.2 ofrece el mejor valor. Para local: Qwen 2.5 Coder 14B es el estándar de oro actual. El factor decisivo es la confiabilidad del tool calling -- Claude Code depende en gran medida de él para las operaciones de archivos, y los modelos Claude nativos lo manejan mejor.

¿Cómo soluciono el error "model not found" en Claude Code?

Configura las tres variables de entorno de ranura de modelo: ANTHROPIC_DEFAULT_HAIKU_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL y ANTHROPIC_DEFAULT_OPUS_MODEL. Este error ocurre porque Claude Code usa tres ranuras de modelo internas, y una ranura no mapeada intenta llamar a un nombre de modelo que tu proxy no reconoce.

¿Puede Claude Code funcionar sin conexión con modelos locales?

Sí. Tanto Ollama como LM Studio ejecutan modelos completamente en tu máquina sin necesidad de conexión a Internet. Tu código nunca sale de tu hardware. Necesitarás especificaciones adecuadas -- 16 GB de RAM como mínimo para modelos de 7B, 32 GB+ para cualquier cosa más grande.

¿Puedo usar LM Studio con Claude Code?

Sí. LM Studio ejecuta un servidor local al que Claude Code se conecta configurando ANTHROPIC_BASE_URL como http://localhost:1234/v1 y ANTHROPIC_API_KEY como lm-studio. Descarga un modelo de codificación como Qwen 2.5 Coder, inicia el servidor desde la GUI de LM Studio y luego mapea tu ranura de modelo. Es la alternativa visual a la CLI de Ollama.

¿Qué es ANTHROPIC_BASE_URL y cómo lo uso?

Es la variable de entorno que le dice a Claude Code dónde enviar las solicitudes de API. Por defecto, apunta a https://api.anthropic.com. Cámbialo a cualquier endpoint compatible con Anthropic -- OpenRouter (https://openrouter.ai/api), Ollama (http://localhost:11434), LiteLLM (http://localhost:4000), etc.

¿Es claude-code-router mejor que LiteLLM?

Herramientas diferentes para problemas diferentes. claude-code-router es más simple (npm install, editar config.json, listo) y diseñado específicamente para Claude Code. LiteLLM es de nivel empresarial con balanceo de carga, limitación de velocidad, cadenas de respaldo y registro de auditoría. ¿Desarrollador individual? Usa claude-code-router. ¿Equipo con necesidades de gobernanza? Usa LiteLLM.

¿Cuánto puedo ahorrar usando modelos no Anthropic?

Cambiar de Claude Opus 4.6 a DeepSeek V3.2 reduce los costos de tokens de salida en aproximadamente 95% (€23 frente a €1,01 por millón de tokens). Ollama lleva eso a cero si tienes el hardware. Pero las compensaciones de calidad son reales -- espera menor precisión en tareas agénticas complejas de múltiples pasos, tool calling menos confiable y más rutas de archivos alucinadas.

¿Funciona el tool calling con todos los métodos de proxy?

No de manera confiable en general. Claude nativo tiene el mejor soporte de tool calling. OpenRouter con modelos Claude funciona casi igual de bien. DeepSeek y Gemini tienen soporte parcial -- las llamadas de herramientas simples funcionan, pero las cadenas complejas pueden fallar. Los modelos locales vía Ollama tienen el tool calling menos confiable. Esta es la principal preocupación de calidad al alejarse de Anthropic.

Fuentes

• Configuración del modelo -- Documentación de Claude Code
• Configuración de la pasarela LLM -- Documentación de Claude Code
• Integración de Claude Code -- Documentación de OpenRouter
• Integración de Claude Code -- Documentación de Ollama
• Precios de la API de Claude -- Anthropic
• claude-code-router -- GitHub
• claude-code-proxy -- GitHub
• Usar Claude Code con modelos no Anthropic -- Documentación de LiteLLM