Guía NIM gratuito para desarrolladores: API, curl, rate limits y fallback chain

TL;DR

• NVIDIA NIM da acceso gratuito a 100+ modelos de IA (DeepSeek, Kimi, MiniMax, Step, Llama, etc.) vía API compatible con OpenAI.
• Sin tarjeta de crédito: te registras, generas una key nvapi- y listo.
• Rate limit real: 40 RPM en el plan gratuito. Basta para prototipar, insuficiente para producción sin manejo de errores.
• La API usa https://integrate.api.nvidia.com/v1 — mismo formato que OpenAI, solo cambias base_url.
• Los modelos más interesantes: Kimi K2.6 (coding agéntico), DeepSeek V4 Flash (1M contexto, 284B MoE), Step 3.7 Flash (razonamiento rápido).

Qué necesitas

• Cuenta gratuita en build.nvidia.com — no requiere tarjeta de crédito
• curl instalado (cualquier sistema con bash)
• Un editor de texto para guardar tus scripts
• Nivel técnico: saber qué es una API REST y qué significa un código HTTP 429

Paso 1: Obtener tu API key

1. Ve a build.nvidia.com
2. Regístrate con email o cuenta NVIDIA
3. Abre cualquier modelo del catálogo (da igual cuál)
4. Pulsa “Get API Key”
5. Copia la key — empieza por nvapi-

Guarda la key como variable de entorno:

export NVIDIA_API_KEY="nvapi-tu-key-aqui"

No compartas esta key ni la subas a ningún repo público.

Paso 2: Entender el endpoint

NIM expone una API compatible con OpenAI. Eso significa que si ya usas el SDK de OpenAI en Python o Node, solo cambias la URL base:

Campo	Valor
Base URL	https://integrate.api.nvidia.com/v1
Auth	Bearer $NVIDIA_API_KEY
Formato	OpenAI Chat Completions
Streaming	Soportado (SSE)

El patrón es idéntico al de OpenAI. La diferencia está en los modelos disponibles y en los rate limits.

Paso 3: Tu primera llamada con curl

curl -X POST "https://integrate.api.nvidia.com/v1/chat/completions" \
  -H "Authorization: Bearer $NVIDIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "moonshotai/kimi-k2.6",
    "messages": [
      {"role": "system", "content": "Eres un asistente técnico conciso."},
      {"role": "user", "content": "Explica Mixture-of-Experts en 3 frases."}
    ],
    "temperature": 0.6,
    "max_tokens": 512
  }'

Si todo funciona, recibirás un JSON estándar de OpenAI con choices[0].message.content.

Paso 4: Modelos disponibles y sus IDs

El catálogo de NIM supera los 100 modelos. Los IDs siguen el formato proveedor/nombre-modelo. Aquí los más relevantes para un desarrollador que busca modelos de alta calidad gratis:

Modelo	ID en NIM	Parámetros (total/activos)	Contexto	Mejor para
Kimi K2.6	moonshotai/kimi-k2.6	1T / 32B (MoE)	256K	Coding agéntico, SWE-Bench 80.2%
DeepSeek V4 Flash	deepseek-ai/deepseek-v4-flash	284B / 13B (MoE)	1M	Razonamiento, código, 1M contexto
Step 3.7 Flash	stepfun-ai/step-3.7-flash	MoE multimodal	—	Razonamiento rápido, agentes
MiniMax M3	minimax/minimax-m3-preview	MoE multimodal	1M	Coding, tool calling, visión
Nemotron 3 Super	nvidia/nemotron-3-super-120b-a12b	120B / 12B	1M	Razonamiento agéntico
Llama 3.3 70B	meta/llama-3.3-70b-instruct	70B	128K	Generalista
GLM 5	zhipu-ai/glm-5	744B (MoE)	—	Razonamiento complejo
DeepSeek R1	deepseek-ai/deepseek-r1	671B (MoE)	128K	Math, código, razonamiento

Para ver el catálogo completo: build.nvidia.com/models.

Paso 5: Rate limits

El plan gratuito de NIM tiene un límite de 40 requests per minute (RPM) por modelo. Esto no es suficiente para producción, pero alcanza para:

• Prototipado y pruebas
• Cron jobs con baja frecuencia (1-2 peticiones por minuto)
• Comparación de modelos
• Agentes con throttling interno

Qué pasa cuando excedes el límite

Recibirás un HTTP 429. La respuesta incluye headers con info sobre cuándo puedes reintentar:

{
  "error": {
    "code": 429,
    "message": "Rate limit exceeded. Try again in X seconds."
  }
}

Estrategia: retry con backoff exponencial

from openai import OpenAI, RateLimitError
import time

client = OpenAI(
    base_url="https://integrate.api.nvidia.com/v1",
    api_key="nvapi-tu-key-aqui"
)

def call_with_retry(messages, model="moonshotai/kimi-k2.6", max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                max_tokens=1024
            )
            return response.choices[0].message.content
        except RateLimitError as e:
            wait = 2 ** attempt  # 1s, 2s, 4s
            print(f"429 en intento {attempt + 1}, esperando {wait}s...")
            time.sleep(wait)
    raise Exception("Rate limit persistente tras retries")

Paso 6: Streaming

Para respuestas largas, el streaming reduce la percepción de latencia:

curl -X POST "https://integrate.api.nvidia.com/v1/chat/completions" \
  -H "Authorization: Bearer $NVIDIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Escribe un resumen de 200 palabras sobre transformers en NLP."}],
    "stream": true
  }'

La respuesta llega como Server-Sent Events (SSE), igual que OpenAI.

Paso 7: Montar una cadena de fallback

La parte útil de tener varios modelos en la misma API es poder hacer fallback entre ellos. Si un modelo devuelve 429, pruebas con otro. Aquí un patrón práctico:

from openai import OpenAI, RateLimitError, APIError
import time

FALLBACK_MODELS = [
    "moonshotai/kimi-k2.6",          # MVP: coding agéntico
    "deepseek-ai/deepseek-v4-flash",  # 1M contexto, razonamiento
    "stepfun-ai/step-3.7-flash",      # Razonamiento rápido
    "nvidia/nemotron-3-super-120b-a12b",  # Generalista
]

def chat_with_fallback(prompt, system="Eres un asistente técnico."):
    client = OpenAI(
        base_url="https://integrate.api.nvidia.com/v1",
        api_key="nvapi-tu-key-aqui"
    )
    messages = [
        {"role": "system", "content": system},
        {"role": "user", "content": prompt}
    ]
    
    for model in FALLBACK_MODELS:
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                max_tokens=1024,
                timeout=30
            )
            return response.choices[0].message.content, model
        except (RateLimitError, APIError) as e:
            print(f"{model} falló ({type(e).__name__}), probando siguiente...")
            time.sleep(1)
            continue
    
    raise Exception("Todos los modelos NIM agotados")

Por qué este orden

1. Kimi K2.6 primero: 80.2% en SWE-Bench, calidad M3-tier, la mejor opción para coding y agentes.
2. DeepSeek V4 Flash segundo: 284B MoE con 1M de contexto. Si necesitas procesar documentos largos, es el go-to.
3. Step 3.7 Flash tercero: rápido, buen razonamiento, buen backup cuando los dos anteriores están saturados.
4. Nemotron al final: modelo generalista de NVIDIA, siempre disponible como último recurso.

El truco está en que son todos modelos distintos con distintos proveedores — la probabilidad de que todos devuelvan 429 a la vez es baja.

Paso 8: Python con el SDK de OpenAI

Si prefieres el SDK en lugar de curl:

from openai import OpenAI

client = OpenAI(
    base_url="https://integrate.api.nvidia.com/v1",
    api_key="nvapi-tu-key-aqui"
)

response = client.chat.completions.create(
    model="moonshotai/kimi-k2.6",
    messages=[
        {"role": "system", "content": "Responde en español, de forma concisa."},
        {"role": "user", "content": "¿Cuáles son las ventajas de MoE frente a modelos densos?"}
    ],
    temperature=0.3,
    max_tokens=512
)

print(response.choices[0].message.content)

Zero cambios respecto a usar GPT-4o o Claude — solo cambias base_url y api_key. Ese es el punto fuerte de NIM: compatible con tu tooling existente.

Problemas comunes

Error	Causa	Solución
401 Unauthorized	API key inválida o ausente	Verifica que empieza con nvapi-
429 Too Many Requests	Más de 40 RPM	Implementa backoff o reduce frecuencia
404 Model not found	ID de modelo incorrecto	Consulta el catálogo en build.nvidia.com
Timeout	Modelos grandes tardan más	Aumenta timeout en el SDK o --max-time en curl
JSON parse error	Falta Content-Type: application/json	Incluye el header en tu petición

Resultado esperado

Al terminar este tutorial serás capaz de:

• Obtener una API key gratuita de NIM sin tarjeta de crédito
• Hacer llamadas a modelos SOTA (Kimi K2.6, DeepSeek V4 Flash, Step 3.7 Flash) con curl y Python
• Manejar rate limits con retry con backoff
• Montar una cadena de fallback que prueba varios modelos automáticamente
• Entender qué modelo usar para cada caso de uso

Siguientes pasos

• Explora el catálogo completo en build.nvidia.com/models
• Para producción, compara NIM con OpenRouter, Together.ai y Z.AI en nuestra guía de costes de LLM
• Si necesitas desplegar modelos propios, consulta la guía de self-hosting con vLLM y llama.cpp
• Para routing entre múltiples proveedores, lee routing multi-modelo 2026

Fuentes

• NVIDIA NIM API Reference
• build.nvidia.com — Catálogo de modelos
• NVIDIA NIM Free API: Rate Limits, Pricing & Keys 2026
• Kimi K2.6 Model Card
• DeepSeek V4 Flash Model Card