API IA gratuite en 2026 : limites, exemples et budget de tokens

Choisir une API IA gratuite selon les limites du compte

Pour un prototype, Groq convient à l'évaluation d'une API texte compatible OpenAI, Gemini Developer API à un modèle texte ou multimodal pris en charge, et OpenRouter à la comparaison de variantes explicitement gratuites. Aucun ne fournit une inférence gratuite illimitée. Le choix dépend du nombre de requêtes, des tokens et des conditions de traitement des données.

Nous avons vérifié les sources officielles le 23 octobre 2026. Nous avons consulté le catalogue public OpenRouter et contrôlé la syntaxe des exemples, sans effectuer d'inférence authentifiée ni de tests de performance ou de disponibilité. Les requêtes ci-dessous sont des instructions à exécuter après vérification de votre compte.

Fournisseur	Accès gratuit	Conditions de facturation	Limite entre développement et production
Groq	Offre Free dans les limites du modèle et de l'organisation	Rester sur Free. Le passage à Developer exige un moyen de paiement et active la facturation à l'usage	Évaluation d'une intégration. Vérifier capacité et exigences de production avant de s'y fier
Gemini Developer API	Tokens d'entrée et de sortie gratuits pour certains modèles et fonctions	Un projet Free Tier n'exige pas de passage au payant. Associer la facturation change le niveau et les conditions de paiement	Vérifier région, quotas et conditions sur les données. Certaines fonctions n'ont pas d'offre gratuite
OpenRouter	Variantes explicitement gratuites dans les limites du compte	Aucun achat de crédits pour l'accès gratuit de base. L'historique d'achat peut relever le plafond quotidien	Évaluation de modèles. Un prix nul dans le catalogue ne garantit pas la capacité
Together AI	Aucun essai gratuit actuel	Premier achat de l'organisation d'au moins 15 dollars, puis au moins 5 dollars	Service payant. Désactiver la recharge automatique sans budget volontaire

Ce tableau suit la facturation Groq, la facturation Gemini et ses tarifs, les limites OpenRouter et les crédits Together. Le guide actuel Together distingue premier achat et achats suivants. Un ancien minimum de 5 dollars ne prouve pas l'existence d'un essai gratuit.

Distinguer quota gratuit, crédits et abonnement de chat

Une allocation API récurrente se renouvelle 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é. Ne le comptez comme budget API que si ses conditions incluent explicitement les appels API.

D'anciens tutoriels présentent les 300 dollars de crédits Google Cloud comme un accès gratuit à Gemini API. Le guide de facturation Gemini actuel exclut les nouveaux Welcome credits pour les comptes ouverts après le 2 mars 2026. La documentation du programme gratuit Cloud exclut également Gemini API dans AI Studio. Appliquez ces règles précises plutôt que l'offre générale de 300 dollars. Un ancien crédit encore admissible et valide n'était pas non plus un quota gratuit récurrent.

La page tarifaire Gemini indique que le contenu de l'offre gratuite peut améliorer les produits Google, selon ses conditions. Examinez cette règle avant d'envoyer des données confidentielles. Une allocation gratuite ne constitue pas un engagement de disponibilité.

Découvrir les identifiants avant une requête

Utilisez Bash ou Zsh avec curl et jq. Fournissez les clés par variables d'environnement locales ou par le gestionnaire de secrets du serveur. Excluez-les du code public du navigateur, des captures, du traçage du shell et des journaux. Les exemples n'affichent pas les clés. Activez pipefail pour qu'une commande échouée dans un pipeline produise un statut d'échec.

Groq

Listez les identifiants accessibles à votre clé. Comparez ensuite un modèle texte au tableau Free Plan et à la page Limits du compte. Le guide des modèles décrit cette découverte. La présence d'un modèle ne prouve pas son quota gratuit.

set -o pipefail
curl --fail-with-body --silent --show-error --max-time 30 \
    'https://api.groq.com/openai/v1/models' \
    -H "Authorization: Bearer ${GROQ_API_KEY:?Set GROQ_API_KEY}" |
    jq -r '.data[].id'

Définissez GROQ_MODEL avec l'identifiant choisi. Cette petite requête utilise le point d'accès de chat documenté. Le guide de compatibilité OpenAI décrit aussi les paramètres incompatibles.

jq -n --arg model "${GROQ_MODEL:?Set GROQ_MODEL}" \
    '{model:$model,messages:[{role:"user",content:"Reply with OK."}],max_completion_tokens:64}' |
    curl --fail-with-body --silent --show-error --max-time 30 \
    'https://api.groq.com/openai/v1/chat/completions' \
    -H "Authorization: Bearer ${GROQ_API_KEY:?Set GROQ_API_KEY}" \
    -H 'Content-Type: application/json' --data-binary @-

OpenRouter

Le catalogue de modèles fournit identifiants, prix et paramètres pris en charge. Ce filtre sélectionne les variantes :free dont les prix texte d'entrée et de sortie sont nuls. Examinez l'objet tarifaire complet et les coûts des fonctions avant utilisation.

curl --fail-with-body --silent --show-error --max-time 30 \
    'https://openrouter.ai/api/v1/models' |
    jq -r '.data[] | select(.id | endswith(":free")) |
    select((.pricing.prompt | tonumber) == 0 and
    (.pricing.completion | tonumber) == 0) | .id'

Définissez OPENROUTER_MODEL avec un identifiant :free vérifié. L'exemple utilise l'API de chat, sans plugin payant ni liste de modèles de secours.

jq -n --arg model "${OPENROUTER_MODEL:?Set OPENROUTER_MODEL}" \
    '{model:$model,messages:[{role:"user",content:"Reply with OK."}],max_tokens:64}' |
    curl --fail-with-body --silent --show-error --max-time 30 \
    'https://openrouter.ai/api/v1/chat/completions' \
    -H "Authorization: Bearer ${OPENROUTER_API_KEY:?Set OPENROUTER_API_KEY}" \
    -H 'Content-Type: application/json' --data-binary @-

La FAQ tarifaire OpenRouter annonce actuellement 20 requêtes par minute et 50 par jour pour les modèles gratuits, puis 1 000 par jour après au moins 10 dollars de crédits achetés. Le plafond supérieur exige donc un achat. Un solde négatif peut aussi bloquer les appels gratuits. Vérifiez le compte au lieu d'acheter automatiquement des crédits.

Avant une longue série, consultez GET https://openrouter.ai/api/v1/key avec authentification. Contrôlez free_model_daily_requests quand ce champ s'applique, les crédits restants et le budget effectif. Multiplier les clés ne contourne pas les limites du compte.

Gemini Developer API

L'API des modèles donne les noms de ressources compatibles avec generateContent. Suivez nextPageToken s'il existe. Vérifiez ensuite le modèle exact et la fonction dans les tarifs gratuits et les limites actives du projet.

model_page_args=()
if [ -n "${GEMINI_PAGE_TOKEN:-}" ]; then
    model_page_args=(--data-urlencode "pageToken=$GEMINI_PAGE_TOKEN")
fi
curl --get --fail-with-body --silent --show-error --max-time 30 \
    'https://generativelanguage.googleapis.com/v1beta/models' \
    --data-urlencode 'pageSize=1000' "${model_page_args[@]}" \
    -H "x-goog-api-key: ${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 un token apparaît, affectez sa valeur à GEMINI_PAGE_TOKEN et relancez ce bloc une fois pour la page suivante. --data-urlencode encode le paramètre pageToken. Arrêtez quand aucun token ne reste et supprimez la variable avant un nouveau parcours.

Définissez GEMINI_MODEL avec le nom complet retourné, préfixe models/ inclus. L'exemple utilise l'authentification par clé et le point d'accès natif generateContent.

curl --fail-with-body --silent --show-error --max-time 30 \
    "https://generativelanguage.googleapis.com/v1beta/${GEMINI_MODEL:?Set GEMINI_MODEL}:generateContent" \
    -H "x-goog-api-key: ${GEMINI_API_KEY:?Set GEMINI_API_KEY}" \
    -H 'Content-Type: application/json' \
    --data-binary '{"contents":[{"parts":[{"text":"Reply with OK."}]}],"generationConfig":{"maxOutputTokens":64}}'

Le plafond de 64 tokens borne ces exemples. Un modèle de raisonnement peut consommer ce budget avant de produire du texte visible. Inspectez la raison de fin et l'usage avant de modifier le plafond. Un nom de modèle retourné ou un HTTP 200 ne prouve pas à lui seul un résultat exploitable.

Calculer si l'allocation suffit

Partez de votre charge prévue, pas de la plus grande fenêtre de contexte annoncée. Cette feuille de calcul décrit une application texte hypothétique. Ce ne sont ni des mesures de trafic ni des quotas d'un fournisseur.

Hypothèse ou calcul	Résultat
60 utilisateurs quotidiens × 5 actions × 2 appels	600 requêtes par jour
800 tokens d'entrée et 200 de sortie par appel	480 000 tokens d'entrée et 120 000 de sortie par jour
Réserve de 20 % pour reprises et actions répétées	720 requêtes, 576 000 tokens d'entrée et 144 000 de sortie par jour
Pointe de 30 appels par minute avant réserve	24 000 tokens d'entrée et 6 000 de sortie par minute
Hypothèse de 4 secondes par appel à ce débit régulier	Environ 2 requêtes simultanées en moyenne

Comptez l'instruction complète, les passages récupérés, les schémas d'outils et l'historique. Chaque étape d'une boucle d'agent ajoute une requête. Utilisez le compteur du fournisseur quand il existe, puis remplacez les estimations par l'usage retourné.

Comparez chaque plafond applicable. Groq peut limiter requêtes et tokens par minute et par jour au niveau de l'organisation. Ses en-têtes distinguent requêtes quotidiennes et tokens par minute. Gemini compte généralement TPM d'entrée, RPM et RPD par projet, avec des limites propres au modèle. Le quota quotidien se réinitialise à minuit, heure du Pacifique. Les limites OpenRouter peuvent bloquer de petites requêtes à cause de leur nombre.

Cette charge dépasse les 50 requêtes quotidiennes et les 20 requêtes par minute annoncées pour l'accès gratuit de base OpenRouter. Relever le plafond quotidien ne résout pas le plafond par minute. Réduisez les appels, mettez-les en file ou choisissez une autre allocation vérifiée.

La concurrence exige un contrôle distinct. Deux requêtes en cours en moyenne n'autorisent pas trente appels simultanés. Mettez les pointes en file, gardez une marge et arrêtez dès qu'un compteur est épuisé. Incluez les autres applications du même projet ou de la même organisation.

Pour estimer un recours payant, calculez coût mensuel = tokens d'entrée / 1 000 000 × prix d'entrée + tokens de sortie / 1 000 000 × prix de sortie. Ajoutez outils, médias et hébergement facturés séparément. Ce calcul n'autorise pas l'activation de la facturation.

Traiter les erreurs sans déclencher de dépense

Inspectez le corps de réponse et le tableau des quotas avant de relever une limite. Le code HTTP seul n'identifie pas le niveau qui bloque.

Réponse	Points à vérifier	Action
429	Plafond par minute, quota quotidien, capacité ou limite de dépenses d'une offre payante	Réessayer après le délai indiqué pour une limite temporaire. Attendre le renouvellement d'un quota quotidien épuisé
402	Solde, plafond de clé ou métadonnées de facturation	Arrêter si les crédits sont épuisés. openrouter_in_flight_budget est une exception temporaire documentée avec Retry-After
403	Permissions, région, règle de sécurité ou budget d'organisation	Corriger la restriction nommée. Répéter n'efface pas un blocage d'autorisation ou de budget
404	URL de base, version d'API, modèle exact et méthode	Actualiser le catalogue et corriger la requête. Ne pas remplacer silencieusement le modèle par un modèle payant
400 ou 401	Paramètres ou validité de la clé	Corriger la requête ou la configuration avant de réessayer

Consultez les erreurs Groq, le dépannage Gemini et les métadonnées d'erreur OpenRouter.

Pour un incident temporaire, définissez une échéance totale et au plus deux nouvelles tentatives comme règle de l'application. Respectez Retry-After quand il existe. Sinon, espacez les tentatives de manière exponentielle avec une part aléatoire. Si l'attente dépasse l'échéance, arrêtez ou mettez en file au lieu de réessayer trop tôt. Vérifiez les reprises automatiques du SDK pour éviter leur multiplication avec votre boucle.

Gardez une liste autorisée de modèles gratuits vérifiés et de fonctions compatibles. Si aucun n'a de capacité, renvoyez une erreur temporaire claire ou mettez la tâche en file. Ne remplacez jamais :free par la variante payante et n'activez ni recharge ni mise à niveau automatiques.

Enregistrez fournisseur, modèle, statut, tokens, nombre de tentatives et identifiant de requête du fournisseur quand il existe. Masquez l'authentification et excluez les instructions et réponses sensibles. Avant la production, testez séparément sortie structurée, outils, annulation et comportement d'échec nécessaires. Notre vérification documentaire ne prouve pas ces résultats.