Accueil / Guides / API LLM gratuite en Python

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èles gratuits rapides avec appel d'outils
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 req/min
250 req/jour
70,000 jetons/min
~6M
OuiOui
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 req/min
50 req/jour
50 req/day account-wide (1,000 after a $10 purchase)
OuiNon
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 de plus131K30 req/min
1,000 req/jour
8,000 jetons/min
200,000 jetons/jour
~6M
OuiNon
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 de plus131K30 req/min
1,000 req/jour
8,000 jetons/min
200,000 jetons/jour
~6M
OuiNon
GPT-OSS Safeguard 20BGroq131K30 req/min
1,000 req/jour
8,000 jetons/min
200,000 jetons/jour
~6M
OuiNon
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditOuiOui
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 req/min
5,000 req/jour
500,000 jetons/jour
500K tokens/day · 5,000 req/day
OuiOui
Nemotron 3.5 Lightning 30BRequesty1M200 req/jour
200 rpd
OuiNon
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui

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âcheChaîne de modèleRaison
Réponses de chat pour les utilisateursautoSuit la chaîne de repli que vous avez définie sur le tableau de bord
Classification, extraction, courts résumésauto:fastClasse les modèles activés par vitesse mesurée
Questions difficiles, revue de code, planificationauto:smartClasse les modèles activés par intelligence
Tâches planifiées qui doivent se terminerauto:reliableClasse les modèles activés par taux de réussite récent
Une chaîne distincte pour une applicationauto:<profile>Utilise une chaîne de repli nommée
Tests qui doivent être reproductiblesUn identifiant de modèle fixeMê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

ExceptionCauseSolution
openai.AuthenticationErrorClé unifiée incorrecteCopiez de nouveau la clé depuis la page Keys
openai.APIConnectionErrorFreeLLMAPI n'est pas lancé, ou le port est incorrectOuvrez http://localhost:3001 dans le navigateur
openai.NotFoundErrorL'URL de base ne contient pas /v1Utilisez http://localhost:3001/v1
openai.RateLimitErrorToutes les clés de la chaîne ont atteint leur limiteAjoutez des fournisseurs, réduisez la concurrence, attendez Retry-After
openai.BadRequestError avec auto:nameLe nom du profil n'existe pasVérifiez le nom du profil sur le tableau de bord
openai.UnprocessableEntityError (422) avec des imagesAucun modèle de vision n'est dans votre chaîneActivez 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.

Utilisez chacun de ces modèles avec une seule clé. FreeLLMAPI est un routeur open source auto-hébergé. Il place toutes ces offres gratuites derrière un seul point de terminaison compatible OpenAI, et bascule vers une autre offre lorsqu'une limite de débit est atteinte. Parcourir le catalogue ou passer en production.

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

Sources

Tous les guides · Parcourir tous les modèles gratuits