Accueil / Guides / API IA gratuite pour un bot Discord ou Telegram

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:fast classe 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.
Confidentialité : le bot envoie les messages des utilisateurs au fournisseur qui répond. Certaines offres gratuites peuvent utiliser les requêtes pour améliorer leurs modèles. Informez vos utilisateurs qu'un service d'IA lit leurs messages. Lisez quelles API LLM gratuites entraînent leurs modèles sur vos données et retirez de votre chaîne les fournisseurs que vous n'acceptez pas.

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èles de chat gratuits rapides
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
Qwen3.8 27BBlazeAPI, ElectronHub, Gizmo +3 de plus262K30 req/min
250 req/jour
70,000 jetons/min
~6M
OuiOui
GPT-OSS 20BApi.Airforce, Cloudflare Workers AI, Groq +4 de plus131K30 req/min
1,000 req/jour
8,000 jetons/min
200,000 jetons/jour
~6M
OuiNon
Nemotron 3.5 LightningElectronHub, Gizmo, Kilo Gateway +2 de plus1M20 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 20B (via Groq)DreamPrompting131K100 req/min
5,000 req/jour
500,000 jetons/jour
500K tokens/day · 5,000 req/day
NonNon
GPT-OSS Safeguard 20BGroq131K30 req/min
1,000 req/jour
8,000 jetons/min
200,000 jetons/jour
~6M
OuiNon
Groq Compound MiniDreamPrompting131K100 req/min
5,000 req/jour
500,000 jetons/jour
500K tokens/day · 5,000 req/day
NonNon
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

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

  1. Ouvrez le Discord Developer Portal et créez une application. Ajoutez un bot et copiez son token.
  2. Dans l'onglet du bot, allez dans Privileged Gateway Intents. Activez Message Content.
  3. Invitez le bot sur votre serveur avec le scope bot et la permission Send Messages.
  4. Définissez le token dans la variable d'environnement DISCORD_TOKEN et 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

  1. Dans Telegram, ouvrez @BotFather et envoyez /newbot. Copiez le token.
  2. Définissez le token dans la variable d'environnement TELEGRAM_TOKEN.
  3. 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.

AgentCommande de configurationCe qu'elle écrit
OpenClawnpx 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 Agentnpx 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èmeCauseSolution
Le bot Discord lit des messages videsL'intention Message Content est désactivéeActivez-la dans le portail et dans intents.message_content
Le bot répond à ses propres messagesAucune vérification des auteurs botsTerminez le traitement lorsque message.author.bot est vrai
Erreur Discord 50035 sur les longues réponsesLe message dépasse 2000 caractèresDécoupez la réponse, comme dans le code ci-dessus
« All free models are busy » le soirToutes les clés de la chaîne ont atteint leur limite quotidienneAjoutez des clés d'autres fournisseurs. De nombreuses limites quotidiennes se réinitialisent à minuit UTC.
Réponses lentesUn modèle lent ou un long historiqueUtilisez auto:fast et gardez 10 messages ou moins
Connection refused depuis le botLe bot tourne dans Docker et utilise localhostUtilisez host.docker.internal ou un réseau Docker partagé
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 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

Sources

Tous les guides · Parcourir tous les modèles gratuits