API LLM gratuite en Python
Le paquet Python officiel openai fonctionne avec toute API compatible OpenAI. Vous changez l'URL de base et la clé. Ce guide utilise FreeLLMAPI, qui regroupe les offres gratuites de 45 fournisseurs derrière une seule clé et passe au fournisseur suivant lorsqu'une limite bloque une requête. Chaque exemple ci-dessous est complet et s'exécute tel quel.
Le code, les noms de modèles et les libellés du catalogue en direct sont affichés en anglais.
Installation
Installez FreeLLMAPI. Il fonctionne dans Docker. Ouvrez le tableau de bord à l'adresse http://localhost:3001, ajoutez des clés gratuites d'au moins deux fournisseurs sur la page Keys et copiez la clé unifiée. Installez ensuite le paquet Python.
Votre code Python n'utilise que la clé unifiée. Les clés des fournisseurs restent dans FreeLLMAPI, chiffrées dans sa base de données. Si vous modifiez ou ajoutez une clé de fournisseur, vous ne changez pas votre code.
Installer
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai
export FREELLMAPI_API_KEY=<unified-key>client.py
import os
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=3, # the SDK retries 429, 408, 409 and 5xx errors
timeout=60,
)
resp = client.chat.completions.create(
model="auto",
messages=[{"role": "user", "content": "Name three uses of Python in one line."}],
)
print(resp.choices[0].message.content)Le modèle auto suit la chaîne de repli de votre tableau de bord. Vous pouvez aussi utiliser auto:fast, auto:smart ou auto:reliable, un profil tel que auto:coding, ou un identifiant de modèle fixe.
Streaming et en-têtes de réponse
Diffuser la réponse
from client import client
stream = client.chat.completions.create(
model="auto:fast",
messages=[{"role": "user", "content": "Write a haiku about Python."}],
stream=True,
)
for chunk in stream:
if chunk.choices:
print(chunk.choices[0].delta.content or "", end="", flush=True)
print()Chaque réponse contient un en-tête X-Routed-Via indiquant le fournisseur et le modèle qui ont répondu. Pour lire les en-têtes avec le SDK, utilisez with_raw_response et appelez parse() pour obtenir l'objet habituel.
Lire les en-têtes de routage
from client import client
raw = client.chat.completions.with_raw_response.create(
model="auto",
messages=[{"role": "user", "content": "hi"}],
)
print("Served by:", raw.headers.get("x-routed-via"))
print("Failed attempts:", raw.headers.get("x-fallback-attempts", "0"))
print(raw.parse().choices[0].message.content)Appel d'outils
Envoyez des tools au format OpenAI. Le routeur les transmet aux fournisseurs compatibles OpenAI et les traduit pour Gemini. La réponse revient dans le même format pour chaque fournisseur.
Un appel d'outil et la réponse finale
import json
from client import client
tools = [{
"type": "function",
"function": {
"name": "get_exchange_rate",
"description": "Get the exchange rate between two currencies.",
"parameters": {
"type": "object",
"properties": {
"base": {"type": "string"},
"quote": {"type": "string"},
},
"required": ["base", "quote"],
},
},
}]
messages = [{"role": "user", "content": "How many euros is 250 US dollars?"}]
first = client.chat.completions.create(model="auto", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"base": args["base"], "quote": args["quote"], "rate": 0.92} # your real lookup
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
final = client.chat.completions.create(model="auto", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)Certains fournisseurs renvoient un appel d'outil sous forme de texte brut. FreeLLMAPI convertit ces réponses en véritables tool_calls, pour que votre code lise un seul format. Vérifiez toujours msg.tool_calls avant de lire msg.content, car un modèle peut aussi répondre sans outil.
Utilisez un modèle avec appel d'outils. Ces modèles gratuits prennent en charge les outils et ont la vitesse mesurée la plus élevée aujourd'hui :
| Modèle | Gratuit sur | Contexte | Limites gratuites (meilleure offre) | Outils | Vision |
|---|---|---|---|---|---|
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 req/min 250 req/jour 70,000 jetons/min ~6M | Oui | Oui |
| Nemotron 3.5 Lightning | ElectronHub, Kilo Gateway, OpenRouter | 1M | 20 req/min 50 req/jour 50 req/day account-wide (1,000 after a $10 purchase) | Oui | Non |
| GPT-OSS 120B | Cloudflare Workers AI, ElectronHub, Groq +1 de plus | 131K | 30 req/min 1,000 req/jour 8,000 jetons/min 200,000 jetons/jour ~6M | Oui | Non |
| GPT-OSS 20B | Cloudflare Workers AI, Groq, NVIDIA NIM +1 de plus | 131K | 30 req/min 1,000 req/jour 8,000 jetons/min 200,000 jetons/jour ~6M | Oui | Non |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 req/min 1,000 req/jour 8,000 jetons/min 200,000 jetons/jour ~6M | Oui | Non |
| Gemini 3.5 Flash Lite | ElectronHub, Google AI Studio | 1M | 15 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| Step 3.7 Flash | ElectronHub | 256K | $0.25/week shared recurring credit | Oui | Oui |
| Gemini 3.1 Flash-Lite | DreamPrompting, Google AI Studio | 1M | 100 req/min 5,000 req/jour 500,000 jetons/jour 500K tokens/day · 5,000 req/day | Oui | Oui |
| Nemotron 3.5 Lightning 30B | Requesty | 1M | 200 req/jour 200 rpd | Oui | Non |
| Gemini 2.5 Flash-Lite | ElectronHub, Google AI Studio | 1M | 15 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
Affichage de 10 modèles gratuits sur 146 correspondants. Voir tous les modèles.
Données en direct du catalogue FreeLLMAPI (version 2026.11.19, vérifié le 2026-11-19). Les limites gratuites changent souvent. Le catalogue est vérifié chaque jour.
Lots asynchrones dans les limites gratuites
AsyncOpenAI envoie de nombreuses requêtes en même temps. Les offres gratuites limitent les requêtes par minute, donc limitez la concurrence avec un sémaphore. L'exemple relance aussi la requête lorsque tous les fournisseurs ont atteint leur limite.
batch.py
import asyncio
import os
import openai
from openai import AsyncOpenAI
client = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
)
limit = asyncio.Semaphore(4) # at most 4 requests at a time
async def summarize(text: str) -> str:
async with limit:
for attempt in range(5):
try:
resp = await client.chat.completions.create(
model="auto:fast",
messages=[
{"role": "system", "content": "Summarize in one sentence."},
{"role": "user", "content": text},
],
)
return resp.choices[0].message.content
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
await asyncio.sleep(min(wait, 60))
return "ERROR: rate limited"
async def main():
docs = [f"Document {i}: Python is a programming language." for i in range(20)]
results = await asyncio.gather(*(summarize(d) for d in docs))
for r in results:
print(r)
await client.close()
asyncio.run(main())Le routeur ne renvoie 429 que lorsque toutes les clés de la chaîne ont atteint leur limite. La réponse contient alors un en-tête Retry-After. Une petite valeur de sémaphore et davantage de clés de fournisseurs donnent les meilleurs résultats pour les grands lots.
Choisir une chaîne de modèle pour chaque tâche
La chaîne de modèle indique au routeur comment choisir un modèle. Vous pouvez utiliser une chaîne différente dans chaque appel. Vous n'avez pas besoin de modifier le tableau de bord.
| Tâche | Chaîne de modèle | Raison |
|---|---|---|
| Réponses de chat pour les utilisateurs | auto | Suit la chaîne de repli que vous avez définie sur le tableau de bord |
| Classification, extraction, courts résumés | auto:fast | Classe les modèles activés par vitesse mesurée |
| Questions difficiles, revue de code, planification | auto:smart | Classe les modèles activés par intelligence |
| Tâches planifiées qui doivent se terminer | auto:reliable | Classe les modèles activés par taux de réussite récent |
| Une chaîne distincte pour une application | auto:<profile> | Utilise une chaîne de repli nommée |
| Tests qui doivent être reproductibles | Un identifiant de modèle fixe | Même modèle à chaque fois, mais s'arrête à la limite de ce modèle |
Pour voir les modèles que vos clés peuvent appeler maintenant, demandez la liste des modèles avec un filtre. La liste complète contient aussi les modèles pour lesquels vous n'avez pas encore de clé.
Lister les modèles qui peuvent répondre maintenant
import os
import httpx
r = httpx.get(
"http://localhost:3001/v1/models",
params={"execution_status": "ready"},
headers={"Authorization": f"Bearer {os.environ['FREELLMAPI_API_KEY']}"},
timeout=30,
)
r.raise_for_status()
for m in r.json()["data"]:
print(m["id"])Un modèle au statut exhausted a des clés, mais toutes ont atteint une limite pour le moment. Le statut disparaît à la fin des délais de repos. Un modèle au statut needsKey n'a aucune clé activée.
Pour une conversation, envoyez un en-tête X-Session-Id avec extra_headers. FreeLLMAPI garde alors cette conversation sur un même modèle pendant 30 minutes. Sans cet en-tête, il utilise un hachage du premier message utilisateur comme clé de session.
Embeddings
Calculer les embeddings d'un texte
from client import client
resp = client.embeddings.create(
model="bge-m3", # one embedding family
input=["Python is a programming language.", "A snake is a reptile."],
)
print(len(resp.data), "vectors of", len(resp.data[0].embedding), "dimensions")Le basculement des embeddings ne change jamais de modèle. Il passe seulement entre les fournisseurs qui servent la même famille, pour que vos vecteurs restent compatibles. La valeur auto utilise la famille par défaut que vous avez définie sur le tableau de bord.
Envoyez de nombreux textes dans une seule liste input. Une requête avec 32 textes compte pour une seule requête de la limite gratuite, et non pour 32. Gardez chaque texte sous l'entrée maximale de la famille. Enregistrez le nom de la famille avec vos vecteurs, pour pouvoir calculer plus tard les requêtes avec la même famille.
Erreurs et corrections
| Exception | Cause | Solution |
|---|---|---|
openai.AuthenticationError | Clé unifiée incorrecte | Copiez de nouveau la clé depuis la page Keys |
openai.APIConnectionError | FreeLLMAPI n'est pas lancé, ou le port est incorrect | Ouvrez http://localhost:3001 dans le navigateur |
openai.NotFoundError | L'URL de base ne contient pas /v1 | Utilisez http://localhost:3001/v1 |
openai.RateLimitError | Toutes les clés de la chaîne ont atteint leur limite | Ajoutez des fournisseurs, réduisez la concurrence, attendez Retry-After |
openai.BadRequestError avec auto:name | Le nom du profil n'existe pas | Vérifiez le nom du profil sur le tableau de bord |
openai.UnprocessableEntityError (422) avec des images | Aucun modèle de vision n'est dans votre chaîne | Activez un modèle de vision dans la chaîne de repli |
Les offres gratuites n'ont aucun contrat de niveau de service. La latence varie au cours de la journée. Les modèles les plus performants atteignent leurs limites quotidiennes en premier, et de nombreuses limites se réinitialisent à minuit UTC. N'utilisez pas une passerelle gratuite pour un service qui doit répondre dans un délai fixe.
Questions fréquentes
Existe-t-il une API LLM gratuite pour Python ?
Oui. De nombreux fournisseurs ont des offres gratuites compatibles avec le paquet Python openai. FreeLLMAPI les combine derrière une seule URL de base et une seule clé, avec basculement entre les fournisseurs.
Comment utiliser la bibliothèque Python openai avec une autre URL de base ?
Passez base_url à OpenAI() ou AsyncOpenAI(), par exemple base_url="http://localhost:3001/v1". Passez votre clé de passerelle comme api_key.
Comment gérer les erreurs de limite de débit en Python ?
Réglez max_retries sur le client. Interceptez openai.RateLimitError, lisez l'en-tête Retry-After et attendez. Limitez la concurrence avec un sémaphore asyncio.
Le streaming fonctionne-t-il avec les API LLM gratuites en Python ?
Oui. Passez stream=True et lisez chunk.choices[0].delta.content. FreeLLMAPI diffuse au format OpenAI pour chaque fournisseur.
Puis-je utiliser Python asynchrone avec une API LLM gratuite ?
Oui. Utilisez AsyncOpenAI avec la même base_url et la même clé. Gardez peu de requêtes parallèles, car les offres gratuites limitent les requêtes par minute.
Guides associés
- URL de base des API gratuites compatibles OpenAI
- API LLM gratuite pour LangChain
- API LLM gratuite pour agents IA
- API LLM gratuite avec appel de fonctions
- Limites de débit des API LLM gratuites
Sources
- OpenAI Python SDK README (async, retries, raw responses, errors) (vérifié le 20 November 2026)
- FreeLLMAPI docs: REST API (chat, streaming, tool calling, embeddings, headers) (vérifié le 20 November 2026)
- FreeLLMAPI docs: degraded mode and failover (vérifié le 20 November 2026)