API IA gratuite en 2026 : limites, exemples et budget de tokens
Choisir une API IA gratuite selon les limites du compte
Pour un prototype, utilisez Groq si vous cherchez une API texte compatible avec OpenAI, Gemini Developer API si vous avez besoin d'un modèle texte ou multimodal pris en charge, ou OpenRouter pour comparer des variantes de modèles explicitement gratuites. Chaque offre plafonne l'inférence gratuite. Le choix dépend du nombre de requêtes, du volume de tokens et de vos exigences de traitement des données.
Le 6 novembre 2026, nous avons exécuté le test OpenRouter ci-dessous et vérifié que l'appel texte avait coûté 0 $ US. Les informations sur Groq, Gemini et Together AI proviennent de leur documentation officielle. Vérifiez les limites de votre projet et du modèle exact avant d'exécuter un exemple.
| Fournisseur | Accès gratuit | Conditions de facturation | Du développement à la production |
|---|---|---|---|
| Groq | Offre Free dans les limites du modèle et de l'organisation | Restez sur l'offre Free. Le passage à Developer exige un moyen de paiement et active la facturation à l'usage | Vous pouvez évaluer l'intégration. Vérifiez la capacité disponible et vos exigences avant de l'utiliser en production |
| Gemini Developer API | Entrées et sorties gratuites pour certains modèles et certaines fonctionnalités | Vérifiez que le projet est sur l'offre Free Tier. Associer la facturation au projet et terminer la configuration de l'offre payante active la facturation à l'usage | Vérifiez l'éligibilité de votre région, les quotas du modèle et les conditions de traitement des données. Certaines fonctionnalités sont réservées aux offres payantes |
| OpenRouter | Variantes de modèles explicitement gratuites dans les limites applicables au compte | L'accès gratuit de base est disponible sans achat de crédits. Les achats de crédits peuvent relever le plafond quotidien | Vous pouvez évaluer des modèles. La capacité disponible peut varier même pour les modèles dont le prix affiché est nul |
| Together AI | Aucun essai gratuit actuellement | Solde prépayé strictement positif. Le premier achat de crédits de l'organisation est d'au moins 15 $ US, les suivants d'au moins 5 $ US | La recharge automatique est facultative. Lorsqu'elle est activée, elle achète des crédits si le solde passe sous le seuil fixé |
Sources du tableau. Facturation Groq, facturation Gemini, tarifs Gemini, limites OpenRouter et crédits Together.
Distinguer quota gratuit, crédits et abonnement de chat
Un quota API récurrent se réinitialise selon les règles du fournisseur. Un crédit promotionnel est un solde limité soumis à des conditions d'éligibilité et d'expiration. Un abonnement de chat couvre le produit grand public annoncé. Comptez-le dans votre budget API uniquement si ses conditions incluent explicitement les appels API.
D'anciens tutoriels présentent les 300 $ US de crédits Google Cloud comme un accès gratuit à l'API Gemini. Les comptes ouverts après le 2 mars 2026 sont exclus des nouveaux crédits de bienvenue. Le programme gratuit de Google Cloud exclut également l'API Gemini dans AI Studio. Fiez-vous à ces règles pour déterminer votre éligibilité. Un ancien crédit encore valable ne couvrait les appels que dans la limite de son solde. Guide de facturation Gemini et programme gratuit de Google Cloud.
La page tarifaire Gemini indique que Google peut utiliser les contenus de l'offre gratuite pour améliorer ses produits, selon les conditions applicables. Vérifiez que ces conditions vous conviennent avant d'envoyer des données confidentielles. Le quota gratuit ne s'accompagne d'aucun engagement de disponibilité.
Trouver les identifiants de modèles avant d'envoyer une requête
Utilisez Bash ou Zsh avec curl 7.76 ou une version ultérieure, ainsi que jq. Fournissez les clés par des variables d'environnement locales ou par le gestionnaire de secrets du serveur. Évitez de les exposer dans le code public du navigateur, les captures d'écran, les traces du shell et les journaux. Les exemples s'exécutent sans afficher les clés. Activez pipefail pour que le pipeline renvoie un statut d'échec si l'une de ses commandes échoue.
Exécuter un appel texte OpenRouter au coût vérifié de 0 $ US
- Ouvrez la liste des modèles gratuits et choisissez un identifiant exact se terminant par
:free. Dans le catalogue, vérifiez les prix des entrées et sorties texte du modèle ainsi que les éventuels frais par requête. Vérifiez aussi le point d'accès du fournisseur indiqué. Affectez l'identifiant àOPENROUTER_MODEL. Liste des modèles gratuits et catalogue des modèles. - Pour ce test, utilisez un espace de travail où les extensions par défaut et BYOK (vos propres clés de fournisseur) sont désactivés. La requête envoie du texte brut et limite la sortie à 64 tokens. Elle fixe les plafonds de prix du point d'accès à zéro et cible un seul modèle, sans bascule vers un autre fournisseur. Les extensions payantes et les frais facturés par les fournisseurs en mode BYOK suivent leurs propres règles. Consultez les règles de routage et les tarifs avant d'activer ces fonctions. Extensions par défaut, BYOK, routage des fournisseurs et tarifs OpenRouter.
- Avant l'appel, vérifiez le quota gratuit du compte associé à votre clé. Les plafonds publiés pour l'accès gratuit standard sont de 20 requêtes par minute et de 50 par jour UTC. Le quota quotidien passe à 1 000 requêtes au seuil publié de 10 $ US d'achats de crédits cumulés sur le compte. Le guide précise la tolérance d'arrondi. Utilisez le compteur ci-dessous pour connaître votre quota réel. Un solde négatif peut bloquer les appels gratuits. Les modèles payants et la recharge automatique peuvent entraîner des frais. Limites OpenRouter et API de consultation de la clé courante.
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}'
Lorsque ce quota s'applique, free_model_daily_requests indique le nombre de requêtes utilisées (used), le plafond (limit) et le nombre de requêtes restantes (remaining). Le quota quotidien du compte se réinitialise à 00 h 00 UTC. Le champ distinct key_spend_remaining indique le montant disponible sous le plafond de dépenses de la clé. La valeur null signifie que la clé n'a pas de plafond. Vérifiez votre solde sur la page Credits.
Le script vérifie le suffixe de l'identifiant avant d'envoyer la requête. Il enregistre les en-têtes et la réponse JSON dans des fichiers locaux pour le diagnostic. Il effectue une seule tentative.
(
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'
)
Affectez à probe_dir le chemin affiché après Probe files:, puis examinez la réponse.
jq '{id, model, provider, error, text: .choices[0].message.content,
finish_reason: .choices[0].finish_reason, usage}' "$probe_dir/body.json"
Lors du test du 6 novembre, le modèle liquid/lfm-2.5-2.6b:free, servi par Liquid, a renvoyé le statut HTTP 200, le texte OK et la raison d'arrêt stop. La requête a utilisé 14 tokens d'entrée et 56 tokens de sortie. La réponse contenait la valeur numérique usage.cost: 0. La fiche de génération de la même requête, consultée avec l'identifiant de la réponse, indiquait également data.total_cost: 0. API de consultation d'une génération.
Lors de votre test, vérifiez le modèle et le fournisseur indiqués, le texte visible, la raison d'arrêt et la présence éventuelle d'une erreur dans le corps de la réponse, même avec un statut HTTP 200. En l'absence du champ usage.cost, le coût reste à vérifier. Consultez la fiche de génération si vous devez confirmer le montant facturé. Notre test portait sur une seule requête texte. Comptabilisation de l'usage.
Groq
Listez les identifiants accessibles avec votre clé. Choisissez un modèle texte et comparez les limites de l'offre Free Plan à celles affichées sur la page Limits de votre compte. Le tableau public du Free Plan indique par exemple que qwen/qwen3.8-27b est limité à 30 requêtes par minute, 1 000 par jour, 8 000 tokens par minute et 200 000 par jour. Avant d'utiliser ces chiffres, vérifiez les limites de votre organisation et de votre projet. Un projet peut imposer un plafond inférieur. L'ajout d'un moyen de paiement et le passage à Developer activent la facturation à l'usage. Guide des modèles, limites du Free Plan, limites de l'organisation et limites des projets.
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'
Affectez l'identifiant choisi à GROQ_MODEL. Cet exemple envoie une requête courte au point d'accès de chat documenté. Le guide de compatibilité OpenAI indique les paramètres non pris en charge. Référence de l'API Groq et guide de compatibilité 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
Utilisez l'API des modèles pour trouver les noms de ressources qui prennent en charge generateContent. Suivez nextPageToken si ce champ est présent. Vérifiez dans AI Studio que la clé est associée à un projet Free Tier, puis consultez les limites en vigueur pour ce projet. La grille tarifaire de Gemini 3.5 Flash-Lite indique par exemple que les entrées et sorties texte standard sont gratuites pour les projets éligibles. L'éligibilité varie selon le modèle et la fonctionnalité. Selon le compte, une offre payante peut exiger des crédits prépayés avec recharge automatique facultative ou permettre le paiement après usage. Consultez le guide de facturation avant d'associer la facturation au projet ou d'activer la recharge. API des modèles, projets AI Studio, limites en vigueur, tarifs de Gemini 3.5 Flash-Lite et guide de facturation Gemini.
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 sortie conserve nextPageToken. Pour la première page, laissez GEMINI_PAGE_TOKEN non définie. Si la réponse contient un jeton de pagination, affectez sa valeur à GEMINI_PAGE_TOKEN et relancez le bloc une fois pour obtenir la page suivante. L'option --data-urlencode encode le paramètre pageToken. Arrêtez quand la réponse ne contient plus de jeton. Supprimez la variable avant de recommencer à lister les modèles.
Affectez à GEMINI_MODEL le nom complet renvoyé, préfixe models/ inclus. L'exemple appelle le point d'accès natif generateContent avec une clé API. Authentification par clé API et référence de 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}}'
Ces exemples plafonnent la sortie à 64 tokens. Un modèle de raisonnement peut épuiser ce budget avant de produire du texte visible. Examinez les raisons d'arrêt et le nombre de tokens consommés avant de modifier le plafond. Pour Gemini, consultez candidates[0].content.parts, finishReason et usageMetadata. Pour Groq, consultez choices[0].message.content, finish_reason et usage.
Calculer si le quota gratuit suffit
Partez de la charge prévue pour votre application. La fenêtre de contexte maximale annoncée indique la taille d'une requête, tandis que le quota limite l'usage cumulé. Le tableau repose sur des hypothèses de trafic pour une application texte.
| Hypothèse ou calcul | Résultat |
|---|---|
| 60 utilisateurs quotidiens × 5 actions × 2 appels au modèle | 600 requêtes par jour |
| 800 tokens d'entrée et 200 tokens de sortie par appel | 480 000 tokens d'entrée et 120 000 tokens de sortie par jour |
| Marge de 20 % pour les nouvelles tentatives et les actions répétées | 720 requêtes, 576 000 tokens d'entrée et 144 000 tokens de sortie par jour |
| Pointe de 30 appels par minute avant la marge | 24 000 tokens d'entrée et 6 000 tokens de sortie par minute |
| 4 secondes par appel à ce débit constant | Environ 2 requêtes en cours en moyenne |
Comptez le prompt complet, y compris les passages récupérés, les schémas des outils et l'historique de la conversation. Chaque étape d'une boucle d'agent ajoute une requête. Utilisez le compteur de tokens du fournisseur s'il est disponible. Remplacez ensuite les estimations par les chiffres d'usage renvoyés.
Comparez chaque plafond applicable. Au niveau de l'organisation, Groq peut limiter le nombre de requêtes et de tokens par minute et par jour. Ses en-têtes distinguent le nombre de requêtes par jour du nombre de tokens par minute. Gemini compte généralement les tokens d'entrée par minute (TPM), les requêtes par minute (RPM) et les requêtes par jour (RPD) au niveau du projet. Des limites propres au modèle s'ajoutent à ces compteurs. Le quota quotidien de requêtes de Gemini se réinitialise selon l'heure du Pacifique. Le nombre de requêtes peut limiter l'accès gratuit à OpenRouter même si les prompts sont courts. Limites Groq et limites Gemini.
Cette charge dépasse les 50 requêtes par jour et les 20 requêtes par minute annoncées pour l'accès gratuit de base à OpenRouter. Même avec un quota quotidien plus élevé, le plafond par minute reste applicable. Pour le modèle Groq de l'exemple, les 30 000 tokens par minute, entrées et sorties cumulées, dépassent les 8 000 TPM. Les 600 000 tokens par jour dépassent les 200 000 TPD. Ces dépassements surviennent avant même d'ajouter la marge. Réduisez le nombre d'appels, raccourcissez les prompts, mettez les tâches en file d'attente ou choisissez une offre dont vous avez vérifié les quotas.
Limitez séparément le nombre de requêtes simultanées. Une moyenne de deux requêtes en cours peut masquer une pointe de trente appels simultanés. Mettez les appels en file d'attente lors des pointes, gardez une marge et arrêtez dès qu'un quota est épuisé. Comptez aussi l'usage des autres applications qui partagent votre projet ou votre organisation.
Si vous envisagez une solution payante, estimez son coût avec coût mensuel = tokens d'entrée / 1 000 000 × prix d'entrée + tokens de sortie / 1 000 000 × prix de sortie. Ajoutez les outils, les médias et l'hébergement facturés séparément. Décidez séparément si vous souhaitez activer la facturation.
Diagnostiquer une erreur HTTP 429 sans passer à l'inférence payante
Relevez le statut HTTP, les en-têtes et le corps de l'erreur pour une tentative. Pour le test OpenRouter, utilisez les fichiers enregistrés. Pour les autres exemples curl, enregistrez les en-têtes avec --dump-header et la réponse avec --output. Gardez ces fichiers en local.
awk 'tolower($0) ~ /^(http\/|retry-after:|x-ratelimit-|x-request-id:|request-id:)/' \
"$probe_dir/headers.txt"
jq '.error' "$probe_dir/body.json"
| Cause possible | Comment repérer la limite | Action |
|---|---|---|
| Plafond de requêtes ou de tokens par minute | Vérifiez les limites en vigueur pour le modèle et le trafic de toutes les applications qui partagent le compte ou le projet. Chez Groq, les en-têtes x-ratelimit-*-requests concernent les requêtes par jour et x-ratelimit-*-tokens les tokens par minute. Gemini peut renvoyer RESOURCE_EXHAUSTED avec le détail du quota |
Ralentissez le traitement de la file et raccourcissez les prompts si vous atteignez le plafond de tokens. Respectez Retry-After si l'en-tête est présent |
| Quota quotidien épuisé | Comparez le compteur quotidien de la clé OpenRouter ou l'usage du projet Gemini au plafond applicable. Pour Groq, consultez les en-têtes du quota quotidien de requêtes et le tableau de bord | Attendez la réinitialisation. Le quota quotidien d'OpenRouter se réinitialise à minuit UTC. Le quota quotidien de requêtes de Gemini se réinitialise à minuit, heure du Pacifique |
| Capacité du fournisseur du modèle | Lorsqu'une limite de débit de la plateforme s'applique, OpenRouter renvoie des en-têtes X-RateLimit-* qui indiquent notamment quand la limite se réinitialise. Une erreur du fournisseur du modèle peut contenir error.metadata.provider_code. Un quota quotidien encore disponible laisse ouvertes deux causes possibles, la capacité du fournisseur ou une limite par minute |
Limitez le nombre de tentatives si l'erreur est temporaire. Au besoin, choisissez explicitement un autre identifiant :free déjà vérifié et effectuez les mêmes contrôles de prix |
| Limite de dépenses sur une période, plafond de dépenses ou crédits épuisés | Un projet Gemini payant peut renvoyer 429 en cas de dépassement de la limite de dépenses sur 10 minutes ou d'un plafond de dépenses. Gemini Prepay peut renvoyer 402 si les crédits sont épuisés. Groq signale un blocage lié aux dépenses par le statut HTTP 400 et le code blocked_api_access |
Si une limite de dépenses sur une période s'applique, attendez sa réinitialisation selon la documentation. Si les crédits sont épuisés ou si vous atteignez un plafond fixe, arrêtez et vérifiez la facturation avant de dépenser davantage |
Documentation des champs de réponse et des limites. Limites de débit Groq, plafonds de dépenses Groq, limites de débit Gemini, facturation Gemini et métadonnées d'erreur OpenRouter.
En cas d'erreur temporaire, configurez votre application pour autoriser au plus deux nouvelles tentatives dans un délai total fixé. Retry-After peut indiquer un délai en secondes ou une date HTTP. Si le serveur ne donne aucune indication, augmentez le délai de manière exponentielle avec une part aléatoire. Si l'attente dépasse le délai total, mettez la tâche en file d'attente ou signalez un échec temporaire. Comptez les tentatives du SDK dans la même limite. Si un statut 429 reste inexpliqué, consultez le tableau de bord des quotas avant d'augmenter le nombre de tentatives.
Pour un statut 402, vérifiez les crédits et les détails de facturation. OpenRouter documente une exception temporaire lorsque la réponse contient le code openrouter_in_flight_budget et l'en-tête Retry-After. Pour un statut 403, corrigez le problème de permission, de politique ou de budget signalé. Pour un statut 404, vérifiez l'URL de base, la version de l'API, l'identifiant du modèle et la méthode. Pour les autres réponses 400 ou 401, corrigez d'abord les paramètres ou les identifiants d'authentification.
Gardez une liste d'identifiants de modèles gratuits vérifiés que vous pouvez utiliser en secours. Si ces modèles manquent de capacité, mettez le travail en file d'attente ou renvoyez une erreur claire. Réservez le choix de modèles payants, le changement d'offre et l'activation de la recharge automatique à une décision de facturation explicite.
Consignez le fournisseur, l'identifiant du modèle, le statut HTTP, le nombre de tokens utilisés, le nombre de nouvelles tentatives et l'identifiant de la requête s'il est disponible. Masquez les clés et excluez les prompts et les réponses sensibles. Avant de vous appuyer sur l'intégration, testez les sorties structurées, les outils et le comportement en cas d'échec dont votre application dépend.