Quelles API LLM gratuites choisir en 2026 ?

GroqCloud, OpenRouter, Cloudflare Workers AI, Mistral et Gemini API sont les 5 options à regarder. Je vais surtout vous aider à choisir selon votre vrai besoin : vitesse, variété de modèles, serverless, test sérieux ou prototype rapide sans exploser le budget.

Pourquoi GroqCloud va si vite ?

GroqCloud va si vite parce que toute la plateforme est pensée pour l’inférence, c’est-à-dire le moment où le modèle génère réellement sa réponse. Pas pour entraîner des modèles. Pas pour faire joli dans une démo. Pour répondre vite, avec une latence très basse.

Le cœur du sujet, c’est leur architecture LPU, pour Language Processing Unit. En gros, c’est une puce optimisée pour faire tourner des modèles de langage avec un débit très élevé. Et ça se sent. GroqCloud est le meilleur choix quand la vitesse d’inférence est prioritaire, surtout si vous construisez un assistant où l’utilisateur attend une réponse immédiate.

Le plan gratuit est aussi intéressant parce qu’il donne accès à de gros modèles comme Groq Compound, GPT-OSS-20B, GPT-OSS-120B ou Qwen3.6-27B. Les limites gratuites ne fonctionnent pas comme une seule enveloppe partagée entre tous les modèles. Elles sont spécifiques par modèle, ce qui est beaucoup plus pratique pour tester plusieurs approches sans tout cramer en une heure.

Chez un client, j’ai vu un assistant IA passer de “sympa mais lent” à “on peut vraiment s’en servir tous les jours” juste en réduisant la latence perçue. C’est bête, mais si la réponse arrive vite, les équipes testent plus, corrigent plus, adoptent plus. Si ça rame, même un bon modèle paraît nul.

Voici un exemple simple avec la bibliothèque Python officielle :

import os  # J'importe os pour lire la clé API depuis les variables d'environnement
from groq import Groq  # J'importe le client officiel Groq

client = Groq(api_key=os.environ.get("GROQ_API_KEY"))  # Je crée le client avec la clé GROQ_API_KEY

completion = client.chat.completions.create(  # Je lance une requête de chat
    model="openai/gpt-oss-20b",  # Je choisis un modèle gratuit disponible dans mon dashboard Groq
    messages=[  # Je prépare les messages envoyés au modèle
        {
            "role": "user",  # Je précise que le message vient de l'utilisateur
            "content": "Résume-moi les avantages de GroqCloud en 5 lignes."  # Je donne la demande au modèle
        }
    ]
)  # Je ferme l'appel API

print(completion.choices[0].message.content)  # J'affiche la réponse générée par le modèle

Il faut remplacer le nom du modèle par celui réellement disponible dans votre compte GroqCloud. Le dashboard reste la source fiable, parce que les modèles gratuits et leurs limites peuvent changer.

Usage	Avantage	Point de vigilance
Agents, chatbots, assistants internes	Latence très basse et vrais prototypes possibles	Vérifier les limites gratuites modèle par modèle
Tests multi-modèles	Accès à de gros modèles gratuits	Remplacer le modèle par celui visible dans le dashboard
Expérience utilisateur temps réel	Réponses rapides, adoption plus naturelle	Qualité et vitesse varient selon le modèle choisi

Pourquoi OpenRouter est pratique ?

OpenRouter est pratique parce que je peux tester beaucoup de modèles depuis une seule API compatible OpenAI. C’est ça son vrai intérêt. Je garde presque le même code, je change juste le nom du modèle, et je compare les réponses.

OpenRouter liste plus de 25 modèles gratuits. Certains modèles utilisent le suffixe :free, par exemple provider/model:free. Il existe aussi openrouter/free, qui route vers un modèle gratuit disponible. C’est très utile pour expérimenter vite, sans passer deux heures à créer des comptes partout.

Il faut quand même garder les limites en tête. Le compte gratuit est limité à 50 requêtes par jour et 20 requêtes par minute. Si vous avez acheté au moins 10 dollars de crédits, la limite quotidienne gratuite monte à 1 000 requêtes par jour, tout en gardant l’accès aux modèles gratuits. C’est honnête pour benchmarker, pas pour absorber un vrai trafic produit.

Le bon cas d’usage, pour moi, c’est le benchmark, la comparaison, l’expérimentation, le POC multi-modèles. J’ai déjà utilisé ça avec un client pour comparer des modèles sur des emails entrants. Même prompt, mêmes données, cinq modèles testés dans l’après-midi. Par contre, si votre app doit être stable, avec un modèle gratuit qui peut changer, ralentir ou disparaître, je ne choisirais pas ça comme socle de production.

import os  # Charge le module pour lire les variables d'environnement
from openai import OpenAI  # Utilise le SDK OpenAI, compatible avec OpenRouter

client = OpenAI(  # Crée le client API
    base_url="https://openrouter.ai/api/v1",  # Pointe le SDK vers OpenRouter au lieu d'OpenAI
    api_key=os.environ["OPENROUTER_API_KEY"]  # Lit la clé API stockée dans l'environnement
)

model = "openrouter/free"  # Choisit un modèle gratuit routé automatiquement par OpenRouter

response = client.chat.completions.create(  # Envoie une requête de chat
    model=model,  # Utilise le modèle défini juste au-dessus
    messages=[  # Déclare les messages envoyés au modèle
        {"role": "user", "content": "Résume ce texte en 3 phrases simples."}  # Donne la consigne utilisateur
    ]  # Ferme la liste des messages
)  # Ferme l'appel API

print(response.choices[0].message.content)  # Affiche la réponse du modèle

Pour basculer d’un modèle à l’autre, je change seulement la variable model. Je peux mettre openrouter/free pour laisser OpenRouter router automatiquement, ou un identifiant avec :free si je veux tester un modèle précis.

Ce qu’OpenRouter fait très bien	Tester vite beaucoup de modèles, comparer les sorties, garder une API compatible OpenAI.
Ce qu’il faut éviter	Construire une production critique sur un modèle gratuit qui peut changer ou devenir indisponible.
Quand je le choisis	Benchmark, POC, expérimentation, sélection rapide d’un modèle avant intégration sérieuse.

Quand choisir Cloudflare Workers AI ?

Je choisis Cloudflare Workers AI quand je veux mettre de l’IA près d’une architecture serverless, sans monter une infra complète. C’est très pratique si votre app tourne déjà sur Cloudflare Workers, Pages, KV, R2 ou Durable Objects. Vous déployez vite, vous restez dans le même écosystème, et vous évitez pas mal de plomberie.

Le point intéressant, c’est que chaque compte reçoit 10 000 Neurons d’inférence par jour gratuitement. Attention, un Neuron n’est pas un token universel. C’est une unité d’inférence propre à Cloudflare. Donc je ne traduis pas ça bêtement en “X tokens gratuits”. Je regarde la consommation réelle dans le dashboard, modèle par modèle. J’ai déjà vu des équipes sous-estimer ça, surtout quand elles changent de modèle sans surveiller.

Cette allocation peut couvrir l’usage de modèles qui seraient normalement tarifés au token, si ces modèles sont disponibles dans le plan Workers Free. C’est là que Cloudflare devient intéressant pour prototyper vite, tester un agent interne, enrichir une API, ou ajouter une couche IA à un produit existant.

Exemple notable : Qwen3.8-27B, ajouté le 17 août 2026, avec 27 milliards de paramètres. Le modèle annonce des capacités vision-langage, du raisonnement, l’appel de fonctions, et un contexte jusqu’à 262k tokens. C’est costaud sur le papier. Mais je ne le présenterais pas comme une promesse universelle pour tous les comptes. Je vérifie toujours dans le dashboard les modèles disponibles, le slug exact, et les limites du plan.

POST https://api.cloudflare.com/client/v4/accounts/ACCOUNT_ID/ai/run/MODEL_SLUG_FROM_DASHBOARD
Authorization: Bearer CLOUDFLARE_API_TOKEN
Content-Type: application/json

{
  "messages": [
    {
      "role": "system",
      "content": "Tu réponds de façon claire et concise."
    },
    {
      "role": "user",
      "content": "Résume ce texte en 3 points."
    }
  ]
}

export default {
  async fetch(request, env) {
    // Récupère le texte envoyé par l’utilisateur.
    const { prompt } = await request.json();

    // Appelle Workers AI avec le modèle configuré dans Cloudflare.
    const result = await env.AI.run("MODEL_SLUG_FROM_DASHBOARD", {
      messages: [
        {
          role: "system",
          content: "Tu réponds simplement, sans blabla."
        },
        {
          role: "user",
          content: prompt
        }
      ]
    });

    // Renvoie la réponse au client au format JSON.
    return Response.json(result);
  }
};

Plateforme	Quand je la choisis	Point fort	Limite à surveiller
Cloudflare Workers AI	Quand mon app est serverless ou déjà chez Cloudflare.	Déploiement rapide, IA proche de l’infra, quota gratuit quotidien.	Les Neurons ne sont pas des tokens, il faut suivre le dashboard.
GroqCloud	Quand je veux surtout de la vitesse d’inférence.	Latence très basse sur certains modèles open source.	Catalogue plus ciblé, dépendance aux modèles disponibles.
OpenRouter	Quand je veux comparer plein de modèles via une seule API.	Large choix de fournisseurs et routage flexible.	Coûts et performances variables selon le modèle choisi.

Que vérifier chez Mistral ?

Chez Mistral, je vérifie d’abord les modèles accessibles, les limites gratuites et les conditions du compte avant de bâtir quoi que ce soit. Mistral mérite clairement sa place dans une sélection d’API LLM gratuites à tester, surtout si vous bossez en français, mais je n’annoncerais jamais un volume gratuit ou une limite chiffrée sans l’avoir validé dans la console officielle au moment du projet. Les offres bougent, les modèles aussi, et j’ai déjà vu un prototype casser juste parce qu’un modèle “dispo hier” ne l’était plus sur le compte client.

Pour un développeur, le vrai sujet n’est pas juste “gratuit ou payant”. C’est plutôt : est-ce que le modèle est stable, est-ce que les limites de requêtes tiennent votre usage, est-ce que les données envoyées sont acceptables côté conformité, et est-ce que l’intégration reste simple quand on passe du test à la production.

Je l’utiliserais surtout pour tester des modèles Mistral, créer des assistants métiers, prototyper vite en français, ou comparer les réponses avec GroqCloud et OpenRouter. GroqCloud est souvent intéressant pour la vitesse. OpenRouter est pratique pour comparer plusieurs fournisseurs. Mistral, lui, a l’avantage d’être très propre à intégrer quand on reste dans son écosystème.

import os  # Charge le module qui permet de lire les variables d’environnement
import requests  # Charge le module utilisé pour appeler l’API en HTTP

api_key = os.environ["MISTRAL_API_KEY"]  # Récupère la clé API depuis l’environnement
model = os.environ["MODEL_NAME_FROM_CONSOLE"]  # Récupère le modèle validé dans la console Mistral

url = "https://api.mistral.ai/v1/chat/completions"  # Définit l’endpoint de chat Mistral
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}  # Prépare l’authentification et le format JSON

payload = {"model": model, "messages": [{"role": "user", "content": "Résume ce texte en français."}]}  # Prépare la requête envoyée au modèle

response = requests.post(url, headers=headers, json=payload, timeout=30)  # Envoie la requête avec un délai maximum de 30 secondes
response.raise_for_status()  # Arrête le script si l’API renvoie une erreur HTTP

print(response.json()["choices"][0]["message"]["content"])  # Affiche la réponse générée par le modèle

• Modèle : Je vérifie que le modèle voulu est bien disponible sur mon compte.
• Quota : Je contrôle le volume gratuit réel dans la console officielle.
• Rate limit : Je regarde les limites de requêtes par minute ou par jour.
• Données envoyées : Je valide si je peux envoyer des données client, métier ou sensibles.
• Coût après le gratuit : Je calcule le prix si le prototype commence à tourner sérieusement.
• Logs : Je regarde ce qui est conservé, combien de temps, et où.
• Passage en production : Je vérifie la stabilité, le support, la facturation et les alertes.

Critère	Décision
Prototype rapide en français	Mistral est un très bon candidat à tester.
Besoin de volume gratuit garanti	Je valide dans la console, je ne me fie pas aux articles.
Comparaison multi-modèles	Je mets Mistral face à GroqCloud et OpenRouter.
Production métier	Je regarde d’abord conformité, limites, logs et coûts réels.

Gemini API sert à quoi ?

Gemini API sert surtout quand je veux prototyper vite avec l’écosystème Google, tester du multimodal, et brancher un modèle sans passer trois heures à comprendre l’offre. Texte, image, raisonnement, génération de contenu, analyse de documents… C’est assez confortable, surtout depuis Google AI Studio, qui permet de tester un prompt, choisir un modèle, puis récupérer ce qu’il faut pour appeler l’API.

Le niveau gratuit est utile pour apprendre, faire des POC, valider une idée ou tester une automatisation. Par contre, je fais toujours attention à un point simple : les limites exactes changent selon le modèle, le compte, la région, et parfois la période. Donc je ne me fie jamais à un chiffre vu dans un article. Je vérifie dans la console au moment de lancer le projet.

Face aux autres fournisseurs, je le positionne comme ça. Gemini est moins orienté vitesse brute que GroqCloud, qui est souvent excellent quand on veut de la latence très basse. Il est moins “catalogue géant multi-fournisseurs” qu’OpenRouter. Mais il devient très intéressant si vous travaillez déjà avec Google, si vous voulez tester image + texte, ou si vous voulez une API simple pour explorer plusieurs modèles Gemini.

# Importe le module os pour lire les variables d’environnement.
import os

# Importe le SDK Google Gen AI pour appeler Gemini depuis Python.
import google.genai as genai

# Crée le client Gemini avec la clé API stockée dans GEMINI_API_KEY.
client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

# Définit le nom du modèle à utiliser.
# Récupérez ce nom dans Google AI Studio ou dans la console Google, dans la liste des modèles disponibles.
MODEL_NAME_FROM_CONSOLE = "models/votre-modele-ici"

# Envoie une demande de génération de contenu au modèle choisi.
response = client.models.generate_content(
    model=MODEL_NAME_FROM_CONSOLE,
    contents="Résume ce texte en 5 lignes pour un dirigeant pressé."
)

# Affiche la réponse texte renvoyée par Gemini.
print(response.text)

Petite prudence, parce que je l’ai déjà vu chez un client : avant de brancher ça dans un workflow sérieux, je vérifie les quotas, les logs conservés, le traitement des données, et si la facturation est activée ou non. Un test gratuit qui bascule sans surveillance, ça peut créer de mauvaises surprises.

Fournisseur	À choisir surtout pour	Point fort
GroqCloud	Vitesse	Très bon choix quand la latence compte plus que le catalogue.
OpenRouter	Variété	Pratique pour tester beaucoup de modèles via une seule API.
Cloudflare Workers AI	Serverless	Intéressant si votre app tourne déjà près de l’infra Cloudflare.
Mistral	Stabilité	Bon compromis européen, API propre, modèles solides en texte.
Gemini API	Écosystème Google	Très bon pour texte, image, raisonnement et prototypage dans Google AI Studio.

Alors, laquelle je choisirais maintenant ?

Je choisirais GroqCloud si la vitesse compte vraiment, OpenRouter si je veux comparer beaucoup de modèles sans ouvrir dix comptes, Cloudflare Workers AI si mon app est déjà serverless ou proche de Cloudflare. Pour Mistral et Gemini API, je les garde dans la short-list, mais je vérifie toujours les limites gratuites et les modèles disponibles dans la console avant de promettre quoi que ce soit. Le gratuit est parfait pour apprendre, tester, benchmarker et sortir un POC propre. Le vrai bénéfice pour vous, c’est d’éviter de perdre du temps avec la mauvaise API dès le départ.

FAQ

• Quelle API LLM gratuite choisir pour commencer ?
  Je commencerais par GroqCloud si vous voulez sentir tout de suite la vitesse d’un modèle. Si votre objectif est de comparer plusieurs modèles, OpenRouter est souvent plus pratique. Si vous êtes déjà dans une logique serverless, Cloudflare Workers AI devient très intéressant.
• OpenRouter est-il adapté à la production ?
  Pas forcément avec les modèles gratuits. OpenRouter est excellent pour tester et comparer, mais les modèles gratuits peuvent tourner. Pour une production stable, je préfère verrouiller un modèle, un fournisseur, des limites claires et un budget maîtrisé.
• GroqCloud est-il vraiment gratuit ?
  GroqCloud propose un plan gratuit avec des limites par modèle. C’est suffisant pour apprendre, prototyper et tester des agents ou chatbots. Comme toujours, je vérifie les quotas exacts dans le dashboard avant de brancher ça sur un usage sérieux.
• Que sont les Neurons de Cloudflare Workers AI ?
  Les Neurons sont l’unité utilisée par Cloudflare pour mesurer l’inférence IA. Le plan gratuit donne une allocation quotidienne de 10 000 Neurons. Ce n’est pas un équivalent universel en tokens, donc le bon réflexe est de suivre la consommation dans Cloudflare.
• Peut-on construire un vrai prototype avec une API LLM gratuite ?
  Oui, largement. Pour un chatbot interne, un agent simple, un test de prompt ou un benchmark de modèles, les plans gratuits suffisent souvent. La limite arrive quand vous avez besoin de stabilité, de SLA, de volume ou de garanties sur les données.

 

 

A propos de l’auteur

Je suis Franck Scandolera, expert et formateur en tracking avancé server-side, Analytics Engineering, automatisation No/Low Code avec n8n, intégration de l’IA en entreprise et SEO/GEO. J’accompagne des équipes qui veulent passer de l’idée IA au prototype fiable, puis à l’industrialisation propre. J’ai travaillé avec des clients comme Logis Hôtel, Yelloh Village, BazarChic, la Fédération Française de Football ou Texdecor. Je dirige webAnalyste et Formations Analytics. Si vous voulez cadrer vos usages IA, vos API LLM ou vos automatisations business, contactez-moi.