Proveedores de IA gratuitos: OpenRouter, Groq, NVIDIA NIM y modelos locales

Por qué hablar de proveedores gratuitos de IA en 2026

En 2026 no necesitas pagar para acceder a modelos de lenguaje de nivel producción. Existen al menos cuatro caminos para usar IA de calidad sin costo: APIs cloud con tier gratuito, routers de modelos gratuitos, infraestructura de NVIDIA para prototipado, y ejecución 100% local. Cada uno tiene ventajas y limitaciones distintas. Esta guía cubre los cuatro.

1. OpenRouter: acceso a decenas de modelos gratuitos

OpenRouter es un agregador de modelos de IA que ofrece 20+ modelos gratuitos con $0 de costo por token. No es un modelo, es un router: enruta tu petición al mejor proveedor disponible.

Free Models Router (openrouter/free)

La forma más simple: usas openrouter/free como modelo y el router selecciona automáticamente un modelo gratuito que soporte las capacidades que tu request necesita (visión, tool calling, structured outputs).

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "openrouter/free", "messages": [{"role": "user", "content": "Hello!"}]}'

Modelos gratuitos destacados

• DeepSeek R1 (free) — modelo de reasoning de DeepSeek
• Llama 3.3 70B (free) — Meta Llama
• Qwen 3 (free) — familia Qwen de Alibaba
• GPT-OSS 120B (free) — modelo open-weights de OpenAI
• NVIDIA Nemotron 3 Super 120B (free) — modelo gigante de NVIDIA

Puedes usar un modelo específico con el sufijo :free:

"model": "meta-llama/llama-3.3-70b-instruct:free"

Límites del tier gratuito

Estado de cuenta	Requests/día	Requests/minuto
Cuenta gratuita	50	20
Con $10+ en créditos	1.000	20

El depósito de $10 es único y no expira. Los requests fallidos también cuentan contra tu cuota diaria, así que implementa retry con backoff.

Ventajas

• Un solo endpoint, una sola API key para 20+ modelos gratuitos
• API compatible con OpenAI
• El router filtra automáticamente por las capacidades que tu request necesita
• Ideal para experimentación y prototipado

2. Groq: inferencia ultra-rápida con chips LPU

Groq no es otro proveedor de IA. Es una empresa que construyó chips propios llamados LPU (Language Processing Unit), diseñados específicamente para inferencia de lenguaje. El resultado: 200-1.000 tokens por segundo, 3-10x más rápido que cualquier proveedor con GPUs.

Modelos disponibles en el tier gratuito

Modelo	Model ID	Velocidad (tok/s)	Contexto	Estado
GPT-OSS 20B	openai/gpt-oss-20b	1.000	131K	Activo — recomendado
GPT-OSS 120B	openai/gpt-oss-120b	500	131K	Activo — recomendado
Llama 4 Scout 17B	meta-llama/llama-4-scout-17b-16e-instruct	750	131K	Activo
Qwen 3.6 27B	qwen/qwen3.6-27b	—	131K	Activo
DeepSeek R1 Distill	deepseek-r1-distill-llama-70b	150-250	128K	Activo
Gemma 2 9B	gemma2-9b-it	400-600	8K	Activo

Nota: Llama 3.3 70B y Llama 3.1 8B fueron deprecados el 16 de agosto de 2026. Sus reemplazos recomendados son GPT-OSS 120B y GPT-OSS 20B.

Límites del tier gratuito

Modelo	RPM	RPD	TPM	TPD
openai/gpt-oss-120b	30	1.000	8K	200K
openai/gpt-oss-20b	30	1.000	8K	200K
llama-3.3-70b-versatile	30	1.000	12K	100K
llama-3.1-8b-instant	30	14.400	6K	500K
llama-4-scout-17b	30	1.000	30K	500K
qwen/qwen3-32b	60	1.000	6K	500K

Sin tarjeta de crédito. Solo necesitas email. El tier es permanente, no es un trial de 14 días.

Cómo empezar

curl https://api.groq.com/openai/v1/chat/completions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "openai/gpt-oss-120b", "messages": [{"role": "user", "content": "In one sentence, what is Groq?"}]}'

La API es compatible con OpenAI: base_url="https://api.groq.com/openai/v1". Funciona con cualquier SDK de OpenAI cambiando una línea.

Ventajas

• Velocidad extrema: 200-1.000 tok/s vs 30-80 tok/s en GPUs
• Sin tarjeta de crédito, sin trial, tier permanente
• API compatible con OpenAI
• Time-to-first-token de 0.7-0.8 segundos
• Ideal para chat en tiempo real y agentes que necesitan respuestas inmediatas

Limitaciones

• Solo modelos open-weights (Llama, Qwen, Gemma, GPT-OSS) — no GPT-4, Claude o Gemini
• Límites de tokens por día pueden ser restrictivos para uso intensivo
• Los modelos deprecados se reemplazan periódicamente

3. NVIDIA NIM: acceso gratuito a modelos gigantescos

NVIDIA NIM (NVIDIA Inference Microservices) ofrece acceso gratuito a modelos gigantescos a través de build.nvidia.com. No hay sistema de créditos: es un trial de evaluación con rate limits por modelo.

Modelos destacados

Modelo	Parámetros	Activos	Contexto	Arquitectura
Nemotron-3-Super-120B	120B	12B	Hasta 1M tokens	LatentMoE (Mamba-2 + MoE + Attention + MTP)
Nemotron-3-Ultra-550B	550B	55B	Hasta 1M tokens	LatentMoE híbrido
Nemotron-3.5-Lightning-30B	30B	3B	—	MoE ligero
Nemotron-3-Nano-Omni-30B	30B	3B	—	Omni-modal (imagen, video, voz, texto)
Nemotron-3-Embed-1B	1B	1B	—	Embedding para RAG y búsqueda semántica

El Nemotron-3-Super-120B es particularmente impresionante: 120B de parámetros totales pero solo 12B activos gracias a su arquitectura LatentMoE. Soporta hasta 1 millón de tokens de contexto y tiene modo de reasoning configurable (enable_thinking=True/False).

Cómo acceder

1. Regístrate gratis en el NVIDIA Developer Program en build.nvidia.com
2. Obtén tu NVIDIA_API_KEY
3. Usa la API compatible con OpenAI:

client = OpenAI(
  base_url="https://integrate.api.nvidia.com/v1",
  api_key="$NVIDIA_API_KEY"
)

completion = client.chat.completions.create(
  model="nvidia/nemotron-3-super-120b-a12b",
  messages=[("role", "user"), ("content", "Explica la arquitectura transformer")],
  temperature=1,
  top_p=0.95,
  max_tokens=16384,
  stream=True
)

Límites

• No hay sistema de créditos: NVIDIA lo reemplazó por rate limits por modelo
• Los límites varían según el modelo y el número de usuarios concurrentes
• Disponible para prototipado, investigación y desarrollo (no producción sin licencia Enterprise)
• Self-hosting: miembros del Developer Program pueden descargar NIM microservices y correrlos en hasta 16 GPUs

Ventajas

• Acceso a modelos de 120B y 550B parámetros sin costo
• Contexto de hasta 1 millón de tokens
• Modelos omni-modales (imagen, video, voz, texto)
• API compatible con OpenAI
• Open weights: puedes descargar y self-hostear

4. Modelos locales: Ollama y llama.cpp

Si quieres ejecutar IA 100% en tu computadora sin internet, esta es la opción. No hay APIs, no hay rate limits, no hay costo. Solo tu hardware.

Ollama: la opción de 5 minutos

Ollama (~179K estrellas en GitHub) envuelve llama.cpp detrás de una interfaz de un solo comando. Descarga modelos, los sirve en localhost:11434 con API compatible con OpenAI, y maneja todo automáticamente.

Instalación

# Linux + macOS
curl -fsSL https://ollama.com/install.sh | sh

# macOS (alternativa)
brew install ollama

# Windows: descarga el installer desde ollama.com

Descargar y ejecutar un modelo

# Llama 3.2 (3B) — 2 GB, ideal para empezar
ollama pull llama3.2
ollama run llama3.2

# Gemma 4 12B — multimodal, 16GB laptop
ollama pull gemma4:12b

# Qwen 3.6 27B — coding flagship
ollama pull qwen3.6:27b

# Llama 3.3 70B — requiere Mac con suficiente memoria unificada
ollama pull llama3.3:70b

API compatible con OpenAI

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # required pero no se usa
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[("role", "user"), ("content", "Hello!")]
)

Desde enero de 2026, Ollama también soporta la Anthropic Messages API, lo que permite usar Claude Code con modelos locales.

llama.cpp: control total

llama.cpp (~124K estrellas) es lo que Ollama usa por debajo. Lo usas directo cuando necesitas control exacto sobre cuantización, GPU offload y parámetros de inferencia.

Build desde fuente

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# CPU-only
cmake -B build && cmake --build build --config Release

# NVIDIA GPU
cmake -B build -DLLAMA_CUDA=ON && cmake --build build --config Release

# Apple Silicon
cmake -B build -DLLAMA_METAL=ON && cmake --build build --config Release

Servir un modelo desde Hugging Face

./build/bin/llama-server \
  -hf Qwen/Qwen3.6-27B-GGUF:Q4_K_M \
  --port 8080 \
  -ngl 99 \
  -c 8192

El flag -ngl controla cuántas capas van al GPU vs CPU. -c setea el contexto (KV cache).

Requisitos de hardware

RAM	Modelos viables	Notas
8 GB	Phi-3 Mini (3.8B), Gemma 2B	Usable pero lento
16 GB	Mistral 7B, Llama 3 8B, Gemma 4 12B	Cómodo en Mac M2/M3
32 GB	Llama 3 70B (4-bit quantization)	Workable
64+ GB	Llama 3 70B full precision, modelos larger	Mac Studio / workstation

Regla general: ~1 GB de RAM por billón de parámetros a 4-bit quantization. Q4_K_M es el sweet spot de calidad/tamaño recomendado.

Ventajas de modelos locales

• Privacidad total: tus prompts nunca salen de tu máquina
• Sin rate limits, sin costo, sin internet
• Funciona con cualquier herramienta que hable la API de OpenAI
• Open source (MIT)
• Soporte para CUDA, Metal, ROCm, Vulkan, SYCL

Comparación de los cuatro proveedores

Característica	OpenRouter	Groq	NVIDIA NIM	Ollama / llama.cpp
Costo	$0 (tier free)	$0 (tier free)	$0 (Developer Program)	$0 (local)
Requiere internet	Sí	Sí	Sí	No
Tarjeta de crédito	No	No	No	N/A
Velocidad	Variable	200-1.000 tok/s	Variable	Depende del hardware
Modelos disponibles	20+ gratuitos	6-8 modelos	126+ modelos	Cualquier GGUF
Modelos grandes	Hasta 120B	Hasta 120B (GPT-OSS)	Hasta 550B (Nemotron Ultra)	Hasta 70B (con 32GB+ RAM)
Contexto máximo	Depende del modelo	131K tokens	1M tokens	Depende del hardware
API compatible OpenAI	Sí	Sí	Sí	Sí
Privacidad	Datos van a la nube	Datos van a la nube	Datos van a la nube	100% local
Ideal para	Experimentación con múltiples modelos	Chat en tiempo real, baja latencia	Modelos gigantes, long context	Privacidad, offline, control total

¿Cuál elegir?

Para prototipar y experimentar

OpenRouter es la mejor puerta de entrada: 20+ modelos gratuitos con un solo endpoint. Si necesitas un modelo específico, usa el sufijo :free.

Para velocidad y chat en tiempo real

Groq no tiene competencia en latencia. 1.000 tokens/segundo significa que la respuesta aparece más rápido de lo que puedes leer. Ideal para agentes que necesitan respuestas inmediatas.

Para modelos gigantes y contexto largo

NVIDIA NIM te da acceso a modelos de 120B y 550B parámetros con hasta 1 millón de tokens de contexto. Si necesitas reasoning complejo o procesar documentos extensos, Nemotron Super 120B es impresionante.

Para privacidad y offline

Ollama es la respuesta más simple. Cinco minutos de setup y tienes un modelo corriendo en tu máquina. Si necesitas control fino sobre cuantización y GPU offload, llama.cpp directo.

Combinándolos

Lo más potente es combinar proveedores: usa OpenRouter como router principal con fallback a Groq para baja latencia, NVIDIA NIM para tareas que requieren contexto largo, y Ollama para todo lo que deba quedar privado. Todos hablan la API de OpenAI, así que el cambio es una línea de configuración.

Conclusión

En 2026, el costo no debería ser una barrera para usar IA. OpenRouter, Groq, NVIDIA NIM y los modelos locales cubren prácticamente cualquier caso de uso sin gastar un centavo. La pregunta ya no es "¿puedo permitirme usar IA?" sino "¿cuál proveedor gratuito se ajusta mejor a mi caso de uso?"

Si estás construyendo un proyecto personal, un prototipo, o simplemente quieres explorar, empieza por OpenRouter. Si necesitas velocidad, Groq. Si necesitas modelos gigantes, NVIDIA NIM. Si necesitas privacidad, Ollama. Y si necesitas todo, combínalos.