API de IA gratuitas en 2026: límites, ejemplos y presupuesto de tokens
Elige una API de IA gratuita según los límites de la cuenta
Para un prototipo, empieza con Groq si buscas una API de texto compatible con OpenAI, con Gemini Developer API si necesitas un modelo de texto o multimodal compatible, o con OpenRouter si quieres comparar variantes marcadas como gratuitas. Todos limitan la inferencia gratuita. Elige según el volumen de peticiones, los tokens y tus requisitos sobre el uso de los datos.
El 6 de noviembre de 2026 ejecutamos la prueba de texto de OpenRouter que aparece más abajo y verificamos que el coste fue de 0 dólares. La información sobre Groq, Gemini y Together AI procede de su documentación oficial. Comprueba tu proyecto y el modelo exacto antes de ejecutar cualquier ejemplo.
| Proveedor | ¿Qué es gratuito? | Requisitos de facturación | Uso en desarrollo y producción |
|---|---|---|---|
| Groq | Acceso con el plan Free dentro de los límites del modelo y la organización | Mantén el plan Free. Pasar a Developer exige un método de pago y activa la facturación por uso | Sirve para evaluar una integración. Confirma la capacidad y los requisitos de producción antes de depender del servicio |
| Gemini Developer API | Entrada y salida gratuitas para ciertos modelos y funciones | Confirma que el proyecto esté en el nivel Free Tier. Vincular la facturación y completar la configuración de pago habilita el uso de pago | Comprueba la disponibilidad en tu región, las cuotas del modelo y las condiciones de uso de datos. Algunas funciones carecen de nivel gratuito |
| OpenRouter | Variantes marcadas como gratuitas dentro de los límites de la cuenta | El acceso gratuito básico está disponible sin comprar créditos. El historial de compras puede aumentar el límite diario | Sirve para evaluar modelos. La capacidad puede agotarse aunque el catálogo indique un precio de cero |
| Together AI | Actualmente carece de prueba gratuita | Requiere un saldo de prepago superior a 0 dólares. La primera compra de la organización debe ser de al menos 15 dólares y las siguientes, de al menos 5 | Si activas la recarga automática, el servicio compra créditos cuando el saldo cae por debajo del umbral |
Consulta la facturación de Groq, la facturación de Gemini y sus precios, los límites de OpenRouter y los créditos de Together.
Distingue las cuotas gratuitas de los créditos y las suscripciones de chat
Una cuota recurrente de API se renueva según las reglas del proveedor. Un crédito promocional es un saldo limitado con requisitos de acceso y fecha de vencimiento. Una suscripción de chat cubre el producto de chat anunciado. Inclúyela en el presupuesto de API solo si sus condiciones cubren expresamente las llamadas a la API.
Algunos tutoriales antiguos presentan el crédito de 300 dólares de Google Cloud como acceso gratuito a la API de Gemini. La guía de facturación de Gemini excluye los nuevos créditos de bienvenida para cuentas abiertas después del 2 de marzo de 2026. El programa gratuito de Cloud también excluye la API de Gemini en AI Studio. Para presupuestar el uso, aplica las condiciones específicas de Gemini. Los créditos anteriores que aún cumplían los requisitos y seguían vigentes se aplicaban como saldo limitado.
Según la página de precios de Gemini, Google puede usar el contenido del nivel gratuito para mejorar sus productos, conforme a sus condiciones. Comprueba si esas condiciones te permiten enviar información confidencial. La cuota gratuita tampoco incluye un compromiso de disponibilidad.
Busca los identificadores de modelo antes de enviar una petición
Usa Bash o Zsh con curl 7.76 o posterior y jq. Proporciona las claves mediante variables de entorno locales o el gestor de secretos del servidor. Evita incluirlas en el código público del navegador, capturas, trazas del shell o registros. Los ejemplos omiten las claves de la salida. Activa pipefail para que la tubería devuelva un estado de error si falla alguno de sus comandos.
Prueba de texto de OpenRouter con un coste verificado de 0 dólares
- Abre la colección de modelos gratuitos. Elige un identificador exacto que termine en
:free. Comprueba en el catálogo el precio de la entrada y la salida de texto, cualquier cargo por petición y el endpoint del proveedor que figura allí. Asigna ese identificador aOPENROUTER_MODEL. - Para esta prueba, usa un espacio de trabajo con los plugins predeterminados y BYOK desactivados. La petición usa texto sin formato, un máximo de 64 tokens de salida, topes de precio de cero para el endpoint y un único modelo con el cambio automático de proveedor desactivado. Los complementos de pago y los cargos del proveedor cuando usas BYOK tienen sus propias reglas de facturación. Antes de habilitarlos, consulta la selección de proveedores y los precios.
- Antes de enviar la petición, comprueba la cuota gratuita de la cuenta a la que pertenece la clave. El límite publicado para el acceso gratuito estándar es de 20 peticiones por minuto y 50 por día en horario UTC. El máximo diario sube a 1.000 peticiones al alcanzar el umbral publicado de 10 dólares acumulados en compras de créditos. La guía contempla un margen de redondeo. Usa el contador de abajo para comprobar tu cuota efectiva. Un saldo negativo puede bloquear las peticiones gratuitas. Los modelos de pago y la recarga automática pueden generar cargos. Consulta los límites de OpenRouter y la API de consulta de la clave actual.
curl -q --fail-with-body --silent --show-error --max-time 30 \
'https://openrouter.ai/api/v1/key' \
-H @<(printf 'Authorization: Bearer %s\n' "${OPENROUTER_API_KEY:?Set OPENROUTER_API_KEY}") |
jq -e '.data | objects | {free_model_daily_requests, key_spend_remaining: .limit_remaining}'
free_model_daily_requests muestra, cuando corresponde, el número de peticiones usadas (used), el límite (limit) y las que quedan (remaining). La cuota diaria de la cuenta se reinicia a las 00:00 UTC. key_spend_remaining indica cuánto queda del límite de gasto de la clave. Si vale null, la clave carece de un límite propio. Consulta tu saldo en la página de créditos.
El script comprueba el sufijo del modelo antes de enviar la petición. Hace un solo intento y guarda las cabeceras y el JSON en archivos locales para el diagnóstico.
(
umask 077
: "${OPENROUTER_API_KEY:?Set OPENROUTER_API_KEY}"
case "${OPENROUTER_MODEL:?Set OPENROUTER_MODEL}" in
*:free) ;;
*) printf '%s\n' 'Choose an exact :free model ID.' >&2; exit 1 ;;
esac
probe_dir=$(mktemp -d) || exit 1
printf 'Probe files: %s\n' "$probe_dir"
request=$(jq -cn --arg model "$OPENROUTER_MODEL" '{
model:$model, messages:[{role:"user",content:"Reply with OK."}],
max_tokens:64, stream:false,
provider:{allow_fallbacks:false,max_price:{prompt:0,completion:0,request:0}}
}') || exit 1
curl -q --proto '=https' --retry 0 --silent --show-error --max-time 30 \
--fail-with-body 'https://openrouter.ai/api/v1/chat/completions' \
-H @<(printf 'Authorization: Bearer %s\n' "$OPENROUTER_API_KEY") \
-H 'Content-Type: application/json' --data-binary "$request" \
--dump-header "$probe_dir/headers.txt" --output "$probe_dir/body.json" \
--write-out 'HTTP %{http_code}\n'
)
Asigna a probe_dir la ruta que aparece después de Probe files: y revisa la respuesta.
jq '{id, model, provider, error, text: .choices[0].message.content,
finish_reason: .choices[0].finish_reason, usage}' "$probe_dir/body.json"
En la prueba del 6 de noviembre, liquid/lfm-2.5-2.6b:free con el proveedor Liquid devolvió HTTP 200, el texto OK y el motivo de finalización stop. La petición usó 14 tokens de entrada y 56 de salida. La respuesta incluyó el valor numérico usage.cost: 0. Consultamos el registro de generación de la misma petición con el identificador de la respuesta. Ese registro confirmó por separado data.total_cost: 0.
Cuando ejecutes tu prueba, comprueba el modelo y el proveedor devueltos, el texto visible, el motivo de finalización y cualquier error en el cuerpo, incluso si recibes HTTP 200. Si falta usage.cost, consulta el registro de generación para confirmar el cargo. Nuestra prueba cubrió una sola petición de texto. Consulta la contabilización del uso.
Groq
Lista los identificadores disponibles para tu clave y comprueba los límites del modelo de texto que elijas en la tabla del plan Free y en la página Limits de tu cuenta. La guía de modelos explica cómo obtener los identificadores. Por ejemplo, la tabla pública del plan Free indica para qwen/qwen3.8-27b 30 peticiones por minuto, 1.000 por día, 8.000 tokens por minuto y 200.000 por día. Antes de usar esas cifras, comprueba los límites de la organización y los límites del proyecto. Un proyecto puede imponer un límite menor. Añadir un método de pago y pasar a Developer activa la facturación por uso.
set -o pipefail
curl -q --fail-with-body --silent --show-error --max-time 30 \
'https://api.groq.com/openai/v1/models' \
-H @<(printf 'Authorization: Bearer %s\n' "${GROQ_API_KEY:?Set GROQ_API_KEY}") |
jq -r '.data[].id'
Asigna a GROQ_MODEL el identificador elegido. El ejemplo envía una petición corta al endpoint de chat. Para saber qué parámetros quedan fuera, consulta la guía de compatibilidad con OpenAI.
request=$(jq -cn --arg model "${GROQ_MODEL:?Set GROQ_MODEL}" \
'{model:$model,messages:[{role:"user",content:"Reply with OK."}],max_completion_tokens:64}') &&
curl -q --fail-with-body --silent --show-error --max-time 30 \
'https://api.groq.com/openai/v1/chat/completions' \
-H @<(printf 'Authorization: Bearer %s\n' "${GROQ_API_KEY:?Set GROQ_API_KEY}") \
-H 'Content-Type: application/json' --data-binary "$request"
Gemini Developer API
Busca nombres de recursos que admitan generateContent con la API de modelos. Si la respuesta contiene nextPageToken, úsalo para consultar la página siguiente. Confirma que la clave pertenece a un proyecto Free Tier en Proyectos de AI Studio y comprueba sus límites activos. Por ejemplo, la entrada y la salida de texto estándar son gratuitas para los proyectos que cumplen los requisitos del modelo Gemini 3.5 Flash-Lite. Los requisitos varían según el modelo y la función. Según la cuenta, la configuración de pago puede requerir créditos de prepago con recarga automática opcional o usar pospago. Antes de vincular la facturación o activar las recargas, consulta la guía de facturación.
model_page_args=()
if [ -n "${GEMINI_PAGE_TOKEN:-}" ]; then
model_page_args=(--data-urlencode "pageToken=$GEMINI_PAGE_TOKEN")
fi
curl -q --get --fail-with-body --silent --show-error --max-time 30 \
'https://generativelanguage.googleapis.com/v1beta/models' \
--data-urlencode 'pageSize=1000' "${model_page_args[@]}" \
-H @<(printf 'x-goog-api-key: %s\n' "${GEMINI_API_KEY:?Set GEMINI_API_KEY}") |
jq '{models:[.models[] |
select((.supportedGenerationMethods // []) | index("generateContent")) | .name],
nextPageToken}'
La salida incluye nextPageToken cuando hay otra página. Para la primera página, deja GEMINI_PAGE_TOKEN sin definir. Si recibes un token, asígnalo a GEMINI_PAGE_TOKEN y ejecuta el bloque una vez para obtener la página siguiente. --data-urlencode codifica el parámetro pageToken. Detente cuando se agoten las páginas y elimina la variable antes de iniciar otro listado.
Asigna a GEMINI_MODEL el nombre completo devuelto, incluido models/. El ejemplo usa autenticación por clave de API y el endpoint nativo generateContent.
curl -q --fail-with-body --silent --show-error --max-time 30 \
"https://generativelanguage.googleapis.com/v1beta/${GEMINI_MODEL:?Set GEMINI_MODEL}:generateContent" \
-H @<(printf 'x-goog-api-key: %s\n' "${GEMINI_API_KEY:?Set GEMINI_API_KEY}") \
-H 'Content-Type: application/json' \
--data-binary '{"contents":[{"parts":[{"text":"Reply with OK."}]}],"generationConfig":{"maxOutputTokens":64}}'
Estos ejemplos limitan la salida a 64 tokens. Los modelos de razonamiento pueden agotar ese presupuesto antes de devolver texto visible. Comprueba el motivo de finalización y el uso antes de cambiar el máximo. En Gemini, revisa candidates[0].content.parts, finishReason y usageMetadata. En Groq, revisa choices[0].message.content, finish_reason y usage.
Calcula si te alcanza la cuota gratuita
Parte de la carga que esperas para tu aplicación. La demanda de la aplicación determina este cálculo aunque el proveedor anuncie ventanas de contexto mayores. El ejemplo usa cifras hipotéticas para una aplicación de texto.
| Supuesto o cálculo | Resultado |
|---|---|
| 60 usuarios diarios × 5 acciones × 2 llamadas al modelo | 600 peticiones al día |
| 800 tokens de entrada y 200 de salida por llamada | 480.000 tokens de entrada y 120.000 de salida al día |
| Reserva del 20 % para reintentos y acciones repetidas | 720 peticiones, 576.000 tokens de entrada y 144.000 de salida al día |
| Pico de 30 llamadas por minuto antes de la reserva | 24.000 tokens de entrada y 6.000 de salida por minuto |
| 4 segundos por llamada a ese ritmo sostenido | Unas 2 peticiones en curso de media |
Cuenta el prompt completo, los pasajes recuperados, los esquemas de las herramientas y el historial de la conversación. Cada paso del bucle de un agente añade otra petición. Usa el contador de tokens del proveedor cuando esté disponible y sustituye las estimaciones por las cifras de uso de la respuesta.
Compara todos los límites aplicables. Groq puede limitar las peticiones y los tokens por minuto y por día a nivel de organización. Sus cabeceras distinguen las peticiones diarias de los tokens por minuto. Gemini suele contar los tokens de entrada por minuto (TPM), las peticiones por minuto (RPM) y las peticiones por día (RPD) de cada proyecto. También aplica límites específicos por modelo. El contador diario de peticiones se reinicia a medianoche, hora del Pacífico. OpenRouter puede limitar el número de peticiones gratuitas incluso si los prompts son cortos.
La carga del ejemplo supera las 50 peticiones diarias y las 20 por minuto que anuncia OpenRouter para el acceso gratuito básico. Con una cuota diaria mayor, seguirías superando el límite por minuto. Para el ejemplo de Groq, los 30.000 tokens por minuto estimados entre entrada y salida superan el límite de 8.000 TPM. Los 600.000 tokens diarios también superan el límite de 200.000 tokens por día (TPD). Ambos cálculos excluyen la reserva. Reduce el número de llamadas, acorta los prompts, pon el trabajo en cola o elige otra cuota que hayas comprobado.
Controla la concurrencia por separado. Una media de dos peticiones en curso no da capacidad para treinta peticiones simultáneas. Pon los picos de peticiones en cola, deja margen y detente cuando se agote cualquier cuota. Si compartes un proyecto o una organización, incluye el consumo de las demás aplicaciones.
Si quieres calcular cuánto costaría recurrir a un plan de pago, usa coste mensual = tokens de entrada / 1.000.000 × precio de entrada + tokens de salida / 1.000.000 × precio de salida. Suma el coste de las herramientas, los medios y el alojamiento que se cobren aparte. Activar la facturación requiere una decisión separada.
Diagnostica HTTP 429 sin pasar a la inferencia de pago
Guarda el estado HTTP, las cabeceras y el cuerpo del error de un intento. Para la prueba de OpenRouter, usa los archivos que guardó el script. En los demás ejemplos con curl, guarda las cabeceras con --dump-header y la respuesta con --output. Conserva esos archivos localmente.
awk 'tolower($0) ~ /^(http\/|retry-after:|x-ratelimit-|x-request-id:|request-id:)/' \
"$probe_dir/headers.txt"
jq '.error' "$probe_dir/body.json"
| Qué encuentras | Cómo identificar el límite | Qué hacer |
|---|---|---|
| Límite de peticiones o tokens por minuto | Comprueba los límites vigentes del modelo y el tráfico actual de todas las aplicaciones que comparten la cuenta o el proyecto. En Groq, las cabeceras x-ratelimit-*-requests indican peticiones por día y las cabeceras x-ratelimit-*-tokens indican tokens por minuto. Gemini puede devolver RESOURCE_EXHAUSTED con detalles de la cuota |
Reduce el ritmo de la cola y acorta los prompts si alcanzas el límite de tokens. Respeta Retry-After cuando aparezca |
| Cuota diaria agotada | Compara el contador diario de la clave de OpenRouter o el consumo del proyecto de Gemini con el límite diario aplicable. En Groq, revisa las cabeceras de peticiones diarias y el panel de límites | Espera a que el proveedor renueve la cuota. OpenRouter la reinicia a medianoche UTC y Gemini reinicia su cuota diaria de peticiones a medianoche, hora del Pacífico |
| Capacidad del proveedor del modelo | Cuando aplica un límite propio, OpenRouter devuelve las cabeceras X-RateLimit-*, que indican, entre otros datos, cuándo se reinicia el límite. Si el fallo viene del proveedor del modelo, la respuesta puede incluir error.metadata.provider_code. Aunque quede cuota diaria, el bloqueo puede deberse a la capacidad del proveedor o al límite por minuto |
Si el fallo es temporal, limita los reintentos. Si hace falta, elige explícitamente otro identificador :free que hayas revisado y repite las comprobaciones de precio |
| Límite de gasto por intervalo, tope de gasto o créditos agotados | Los proyectos de pago de Gemini pueden devolver 429 si alcanzan el límite de gasto de 10 minutos o el tope de gasto. Gemini Prepay puede devolver 402 cuando se agotan los créditos. Groq señala un bloqueo por gasto con HTTP 400 y blocked_api_access |
Si alcanzas un límite de gasto por intervalo, espera al reinicio documentado. Si se agotan los créditos o alcanzas un tope de gasto, detente y revisa la facturación antes de gastar más |
Consulta los límites de uso de Groq y sus límites de gasto, los límites de uso de Gemini y su facturación, y los metadatos de error de OpenRouter.
Para un fallo temporal, permite como máximo dos reintentos dentro del plazo total que defina tu aplicación. Retry-After puede indicar una espera en segundos o una fecha en formato HTTP. Si el servidor no indica cuánto esperar, aumenta la espera de forma exponencial con una variación aleatoria. Si la espera supera el plazo, pon el trabajo en cola o devuelve un error temporal. Cuenta los reintentos del SDK dentro del mismo máximo. Si aparece un 429 cuya causa desconoces, revisa el panel de cuotas antes de aumentar el número de reintentos.
Ante un 402, revisa los créditos y los datos de facturación. OpenRouter documenta una excepción temporal para openrouter_in_flight_budget con Retry-After. Ante un 403, corrige la restricción de permisos, políticas o presupuesto que indique la respuesta. Ante un 404, comprueba la URL base, la versión de la API, el identificador del modelo y el método. Para otros errores 400 o 401, corrige primero los parámetros o las credenciales.
Mantén una lista de identificadores de modelos gratuitos que hayas revisado y puedas usar como alternativa. Si se agota su capacidad, pon el trabajo en cola o devuelve un error claro. Exige una decisión explícita sobre la facturación antes de elegir modelos de pago, cambiar de plan o activar la recarga automática.
Registra el proveedor, el identificador del modelo, el estado, los tokens consumidos, el número de reintentos y el identificador de la petición cuando esté disponible. Oculta las claves y omite los prompts y las respuestas sensibles. Antes de depender de la integración, comprueba la salida estructurada, las herramientas y el comportamiento ante los fallos que tu aplicación deba manejar.