API IA gratuite pour un bot Discord ou Telegram
Un bot de conversation envoie une requête de modèle pour chaque message. Sur un serveur très actif, une offre gratuite atteint sa limite en quelques minutes. Ce guide connecte un bot Discord et un bot Telegram à FreeLLMAPI. FreeLLMAPI regroupe les offres gratuites de 45 fournisseurs derrière une seule clé compatible OpenAI et passe au fournisseur suivant lorsqu'une limite bloque une requête. Le code est en Python et il est complet.
Le code, les noms de modèles et les libellés du catalogue en direct sont affichés en anglais.
Prévoir les limites d'abord
Les offres gratuites limitent les requêtes par minute et par jour. Un bot sur un serveur de 200 utilisateurs actifs peut envoyer des milliers de requêtes par jour. Le basculement répartit ces requêtes entre toutes vos clés, mais le total reste la somme des limites gratuites.
- Répondez seulement sur demande. Sur Discord, répondez seulement aux mentions. Dans les groupes Telegram, répondez seulement aux commandes ou aux réponses.
- Limitez chaque utilisateur. Autorisez une requête par utilisateur toutes les quelques secondes.
- Gardez un historique court. Envoyez les 10 derniers messages, et non l'historique complet du canal.
- Utilisez une route rapide.
auto:fastclasse les modèles par vitesse. Les utilisateurs attendent moins. - Échouez poliment. Lorsque toutes les clés ont atteint leur limite, demandez à l'utilisateur de réessayer plus tard.
Ces modèles gratuits ont aujourd'hui la vitesse mesurée la plus élevée. Beaucoup ont des limites de requêtes élevées :
| Modèle | Gratuit sur | Contexte | Limites gratuites (meilleure offre) | Outils | Vision |
|---|---|---|---|---|---|
| Qwen3.8 27B | BlazeAPI, ElectronHub, Gizmo +3 de plus | 262K | 30 req/min 250 req/jour 70,000 jetons/min ~6M | Oui | Oui |
| GPT-OSS 20B | Api.Airforce, Cloudflare Workers AI, Groq +4 de plus | 131K | 30 req/min 1,000 req/jour 8,000 jetons/min 200,000 jetons/jour ~6M | Oui | Non |
| Nemotron 3.5 Lightning | ElectronHub, Gizmo, Kilo Gateway +2 de plus | 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 (via Groq) | DreamPrompting | 131K | 100 req/min 5,000 req/jour 500,000 jetons/jour 500K tokens/day · 5,000 req/day | Non | 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 |
| Groq Compound Mini | DreamPrompting | 131K | 100 req/min 5,000 req/jour 500,000 jetons/jour 500K tokens/day · 5,000 req/day | Non | 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 |
Affichage de 10 modèles gratuits sur 215 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.
Code partagé : l'appel au modèle
Les deux bots utilisent le même module. Il garde un historique court pour chaque conversation, envoie un identifiant de session par conversation et gère les limites de débit. Installez d'abord FreeLLMAPI et copiez la clé unifiée depuis la page Keys du tableau de bord.
Installer
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai discord.py python-telegram-bot
export FREELLMAPI_API_KEY=<unified-key>brain.py
import asyncio
import os
import time
from collections import defaultdict, deque
import openai
from openai import AsyncOpenAI
llm = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
timeout=60,
)
SYSTEM = "You are a helpful chat bot. Answer in short paragraphs."
history = defaultdict(lambda: deque(maxlen=10)) # chat id -> last 10 messages
last_call = {} # user id -> time of the last request
COOLDOWN_S = 5
async def ask(chat_id: str, user_id: str, text: str) -> str:
now = time.monotonic()
if now - last_call.get(user_id, 0) < COOLDOWN_S:
return "Please wait a few seconds before the next question."
last_call[user_id] = now
turns = history[chat_id]
turns.append({"role": "user", "content": text[:4000]})
messages = [{"role": "system", "content": SYSTEM}, *turns]
for attempt in range(3):
try:
resp = await llm.chat.completions.create(
model="auto:fast",
messages=messages,
max_tokens=800,
extra_headers={"X-Session-Id": f"chat-{chat_id}"},
)
answer = resp.choices[0].message.content or "(no answer)"
turns.append({"role": "assistant", "content": answer})
return answer
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
if wait > 30:
break
await asyncio.sleep(wait)
except openai.APIError:
break
turns.pop() # forget the unanswered question
return "All free models are busy now. Please try again later."
def split(text: str, size: int) -> list[str]:
return [text[i:i + size] for i in range(0, len(text), size)] or [""]L'en-tête X-Session-Id garde une conversation sur un même modèle pendant 30 minutes. Le bot garde ainsi le même style dans une conversation. Si ce modèle atteint sa limite, le routeur passe à un autre modèle, qui reçoit le même historique.
L'historique et les délais de repos sont conservés en mémoire. Ils sont perdus au redémarrage du bot. Pour un bot qui doit mémoriser de longues conversations, enregistrez l'historique dans une base de données telle que SQLite ou Redis.
Bot Discord avec discord.py
- Ouvrez le Discord Developer Portal et créez une application. Ajoutez un bot et copiez son token.
- Dans l'onglet du bot, allez dans Privileged Gateway Intents. Activez Message Content.
- Invitez le bot sur votre serveur avec le scope
botet la permission Send Messages. - Définissez le token dans la variable d'environnement
DISCORD_TOKENet lancez le script.
discord_bot.py
import os
import discord
from brain import ask, split
intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)
@client.event
async def on_ready():
print(f"Logged in as {client.user}")
@client.event
async def on_message(message: discord.Message):
if message.author.bot or client.user not in message.mentions:
return
text = message.content
for tag in (f"<@{client.user.id}>", f"<@!{client.user.id}>"):
text = text.replace(tag, "")
text = text.strip()
if not text:
return
async with message.channel.typing():
answer = await ask(str(message.channel.id), str(message.author.id), text)
parts = split(answer, 2000) # Discord limit: 2000 characters
await message.reply(parts[0])
for part in parts[1:]:
await message.channel.send(part)
client.run(os.environ["DISCORD_TOKEN"])Bot Telegram avec python-telegram-bot
- Dans Telegram, ouvrez @BotFather et envoyez
/newbot. Copiez le token. - Définissez le token dans la variable d'environnement
TELEGRAM_TOKEN. - Lancez le script. Envoyez un message à votre bot.
telegram_bot.py
import os
from telegram import Update
from telegram.constants import ChatAction
from telegram.ext import Application, ContextTypes, MessageHandler, filters
from brain import ask, split
async def on_text(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
chat_id = update.effective_chat.id
await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
answer = await ask(str(chat_id), str(update.effective_user.id), update.message.text)
for part in split(answer, 4096): # Telegram limit: 4096 characters
await update.message.reply_text(part)
def main() -> None:
app = Application.builder().token(os.environ["TELEGRAM_TOKEN"]).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, on_text))
app.run_polling(allowed_updates=Update.ALL_TYPES)
if __name__ == "__main__":
main()L'indicateur de saisie dans Telegram reste affiché 5 secondes ou moins. Pour les modèles lents, renvoyez l'action de saisie pendant les longues requêtes. Le code utilise python-telegram-bot version 22, entièrement asynchrone.
Agents de bot prêts à l'emploi
Si vous ne voulez pas écrire de bot, deux agents peuvent répondre sur Discord et Telegram et utiliser FreeLLMAPI comme modèle. FreeLLMAPI propose une commande de configuration pour chacun. Chaque commande accepte --dry-run et crée d'abord une sauvegarde de la configuration.
| Agent | Commande de configuration | Ce qu'elle écrit |
|---|---|---|
| OpenClaw | npx freellmapi setup-openclaw --url http://localhost:3001 --api-key <unified-key> | Un fournisseur freellmapi dans ~/.openclaw/openclaw.json, modèle par défaut freellmapi/auto |
| Hermes Agent | npx freellmapi setup-hermes --url http://localhost:3001 --api-key <unified-key> | Un bloc de modèle personnalisé dans ~/.hermes/config.yaml |
Une passerelle OpenClaw ou Hermes en cours d'exécution doit être redémarrée après la commande de configuration.
Lancez le bot et FreeLLMAPI sur le même ordinateur ou serveur. Le bot atteint alors la passerelle sur localhost, et le port de la passerelle reste fermé à Internet. Un petit serveur ou un Raspberry Pi suffit pour les deux.
Dépannage
| Problème | Cause | Solution |
|---|---|---|
| Le bot Discord lit des messages vides | L'intention Message Content est désactivée | Activez-la dans le portail et dans intents.message_content |
| Le bot répond à ses propres messages | Aucune vérification des auteurs bots | Terminez le traitement lorsque message.author.bot est vrai |
| Erreur Discord 50035 sur les longues réponses | Le message dépasse 2000 caractères | Découpez la réponse, comme dans le code ci-dessus |
| « All free models are busy » le soir | Toutes les clés de la chaîne ont atteint leur limite quotidienne | Ajoutez des clés d'autres fournisseurs. De nombreuses limites quotidiennes se réinitialisent à minuit UTC. |
| Réponses lentes | Un modèle lent ou un long historique | Utilisez auto:fast et gardez 10 messages ou moins |
Connection refused depuis le bot | Le bot tourne dans Docker et utilise localhost | Utilisez host.docker.internal ou un réseau Docker partagé |
Questions fréquentes
Existe-t-il une API IA gratuite pour un bot Discord ?
Oui. Plusieurs fournisseurs ont des offres gratuites compatibles avec le paquet Python openai. FreeLLMAPI les combine derrière une seule clé, donc un bot très actif peut utiliser les limites de nombreux fournisseurs.
Puis-je créer un bot Telegram IA gratuit ?
Oui. Utilisez python-telegram-bot pour le bot et une API gratuite compatible OpenAI pour les réponses. Le code de cette page est complet.
Comment empêcher mon bot IA d'atteindre les limites de débit ?
Répondez seulement aux mentions ou aux commandes, limitez chaque utilisateur à une requête toutes les quelques secondes, gardez un historique court et ajoutez des clés d'autres fournisseurs.
Pourquoi mon bot Discord reçoit-il un contenu de message vide ?
L'intention Message Content est désactivée. Activez-la dans le Developer Portal, dans l'onglet du bot, et définissez intents.message_content = True dans le code.
Que se passe-t-il lorsque tous les modèles gratuits ont atteint leur limite ?
FreeLLMAPI renvoie l'erreur 429 avec un en-tête Retry-After. Le code du bot intercepte cette erreur et demande à l'utilisateur de réessayer plus tard.
Guides associés
- API LLM gratuite en Python
- Limites de débit des API LLM gratuites
- URL de base des API gratuites compatibles OpenAI
- API LLM gratuite pour agents IA
- API LLM gratuite sans carte bancaire
Sources
- discord.py docs: quickstart (vérifié le 20 November 2026)
- discord.py docs: privileged intents (vérifié le 20 November 2026)
- Discord developer docs: message resource (2000 character content limit) (vérifié le 20 November 2026)
- python-telegram-bot v22 docs: echobot example (vérifié le 20 November 2026)
- Telegram Bot API: sendMessage and sendChatAction (vérifié le 20 November 2026)
- FreeLLMAPI docs: clients (OpenClaw, Hermes Agent, context handoff) (vérifié le 20 November 2026)