Home / Gidsen / Gratis AI-API voor een Discord- of Telegram-bot

Gratis AI-API voor een Discord- of Telegram-bot

Een chatbot stuurt bij elk bericht een modelverzoek. Op een drukke server bereikt één gratis tier zijn limiet binnen enkele minuten. Deze gids verbindt een Discord-bot en een Telegram-bot met FreeLLMAPI. FreeLLMAPI bundelt 45 gratis providertiers achter één OpenAI-compatibele sleutel en schakelt over naar de volgende provider wanneer een limiet een verzoek stopt. De code is in Python en volledig.

Code, modelnamen en labels uit de live catalogus worden in het Engels getoond.

Plan eerst voor de limieten

Gratis tiers beperken verzoeken per minuut en per dag. Een bot op een server met 200 actieve gebruikers kan duizenden verzoeken per dag sturen. Failover verdeelt deze verzoeken over al je sleutels, maar het totaal is nog steeds de som van de gratis limieten.

  • Antwoord alleen wanneer je wordt gevraagd. Antwoord in Discord alleen op vermeldingen. Antwoord in Telegram-groepen alleen op commando's of antwoorden.
  • Beperk elke gebruiker. Sta één verzoek per gebruiker toe elke paar seconden.
  • Houd de geschiedenis kort. Stuur de laatste 10 berichten, niet de volledige kanaalgeschiedenis.
  • Gebruik een snelle route. auto:fast rangschikt modellen op snelheid. Chatgebruikers wachten minder.
  • Faal beleefd. Wanneer elke sleutel zijn limiet heeft bereikt, vraag de gebruiker het later opnieuw te proberen.
Privacy: de bot stuurt berichten van gebruikers naar de provider die antwoordt. Sommige gratis tiers kunnen prompts gebruiken om hun modellen te verbeteren. Vertel je gebruikers dat een AI-dienst hun berichten leest. Lees welke gratis LLM-API's trainen op je gegevens en verwijder providers uit je keten die je niet accepteert.

Deze gratis modellen hebben vandaag de snelste gemeten snelheid. Veel ervan hebben hoge verzoeklimieten:

Snelle gratis chatmodellen
ModelGratis opContextGratis limieten (beste aanbod)ToolsVision
Qwen3.8 27BBlazeAPI, ElectronHub, Gizmo +3 meer262K30 aanvragen/min
250 aanvragen/dag
70,000 tokens/min
~6M
JaJa
GPT-OSS 20BApi.Airforce, Cloudflare Workers AI, Groq +4 meer131K30 aanvragen/min
1,000 aanvragen/dag
8,000 tokens/min
200,000 tokens/dag
~6M
JaNee
Nemotron 3.5 LightningElectronHub, Gizmo, Kilo Gateway +2 meer1M20 aanvragen/min
50 aanvragen/dag
50 req/day account-wide (1,000 after a $10 purchase)
JaNee
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 meer131K30 aanvragen/min
1,000 aanvragen/dag
8,000 tokens/min
200,000 tokens/dag
~6M
JaNee
GPT-OSS 20B (via Groq)DreamPrompting131K100 aanvragen/min
5,000 aanvragen/dag
500,000 tokens/dag
500K tokens/day · 5,000 req/day
NeeNee
GPT-OSS Safeguard 20BGroq131K30 aanvragen/min
1,000 aanvragen/dag
8,000 tokens/min
200,000 tokens/dag
~6M
JaNee
Groq Compound MiniDreamPrompting131K100 aanvragen/min
5,000 aanvragen/dag
500,000 tokens/dag
500K tokens/day · 5,000 req/day
NeeNee
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 aanvragen/min
20 aanvragen/dag
250,000 tokens/min
~3M
JaJa
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditJaJa
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 aanvragen/min
5,000 aanvragen/dag
500,000 tokens/dag
500K tokens/day · 5,000 req/day
JaJa

Toont 10 van 215 overeenkomende gratis modellen. Bekijk alle modellen.

Actuele gegevens uit de FreeLLMAPI-catalogus (versie 2026.11.19, gecontroleerd 2026-11-19). Gratis limieten veranderen vaak. De catalogus wordt elke dag gecontroleerd.

Gedeelde code: de modelaanroep

Beide bots gebruiken dezelfde module. Die houdt een korte geschiedenis bij voor elke chat, stuurt één sessie-ID per chat en behandelt ratelimieten. Installeer eerst FreeLLMAPI en kopieer de uniforme sleutel van de pagina Keys van het dashboard.

Installeren

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 [""]

De header X-Session-Id houdt één chat 30 minuten op één model. De bot behoudt dan dezelfde stijl binnen een gesprek. Als dat model zijn limiet bereikt, schakelt de router naar een ander model, dat dezelfde geschiedenis krijgt.

De geschiedenis en de wachttijden worden in het geheugen bewaard. Ze gaan verloren wanneer de bot opnieuw start. Voor een bot die lange gesprekken moet onthouden, sla je de geschiedenis op in een database zoals SQLite of Redis.

Discord-bot met discord.py

  1. Open de Discord Developer Portal en maak een applicatie aan. Voeg een bot toe en kopieer het token.
  2. Ga op het tabblad bot naar Privileged Gateway Intents. Zet Message Content aan.
  3. Nodig de bot uit voor je server met de scope bot en de permissie Send Messages.
  4. Zet het token in de omgevingsvariabele DISCORD_TOKEN en voer het script uit.

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"])

Telegram-bot met python-telegram-bot

  1. Open in Telegram @BotFather en stuur /newbot. Kopieer het token.
  2. Zet het token in de omgevingsvariabele TELEGRAM_TOKEN.
  3. Voer het script uit. Stuur een bericht naar je 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()

De typstatus in Telegram blijft 5 seconden of minder staan. Voor trage modellen stuur je de chatactie opnieuw tijdens lange verzoeken. De code gebruikt python-telegram-bot versie 22, dat volledig asynchroon is.

Kant-en-klare botagents

Als je geen bot wilt schrijven, kunnen twee agents antwoorden op Discord en Telegram en gebruiken ze FreeLLMAPI als hun model. FreeLLMAPI heeft voor elk een setupcommando. Elk commando ondersteunt --dry-run en maakt eerst een back-up van de configuratie.

AgentSetupcommandoWat het schrijft
OpenClawnpx freellmapi setup-openclaw --url http://localhost:3001 --api-key <unified-key>Een provider freellmapi in ~/.openclaw/openclaw.json, standaardmodel freellmapi/auto
Hermes Agentnpx freellmapi setup-hermes --url http://localhost:3001 --api-key <unified-key>Een eigen modelblok in ~/.hermes/config.yaml

Een draaiende OpenClaw- of Hermes-gateway moet opnieuw worden gestart na het setupcommando.

Draai de bot en FreeLLMAPI op dezelfde computer of server. De bot bereikt de gateway dan via localhost, en de gatewaypoort blijft gesloten voor het internet. Een kleine server of een Raspberry Pi is genoeg voor beide.

Problemen oplossen

ProbleemOorzaakOplossing
De Discord-bot leest lege berichtenDe intentie Message Content staat uitZet hem aan in de portal en in intents.message_content
De bot antwoordt op zijn eigen berichtenEr is geen controle op bot-auteursKeer terug wanneer message.author.bot waar is
Discord-fout 50035 bij lange antwoordenHet bericht is langer dan 2000 tekensSplits het antwoord, zoals in de code hierboven
"All free models are busy" in de avondAlle sleutels in de keten hebben hun dagelijkse limiet bereiktVoeg sleutels van meer providers toe. Veel dagelijkse limieten worden om middernacht UTC gereset.
Trage antwoordenEen traag model of een lange geschiedenisGebruik auto:fast en houd 10 berichten of minder
Connection refused van de botDe bot draait in Docker en gebruikt localhostGebruik host.docker.internal of een gedeeld Docker-netwerk
Gebruik elk van deze met één sleutel. FreeLLMAPI is een open-source router die u zelf host. Die zet al deze gratis tarieven achter één eindpunt dat compatibel is met OpenAI. Bij een snelheidslimiet schakelt de router automatisch over. Bekijk de catalogus of live gaan.

Veelgestelde vragen

Is er een gratis AI-API voor een Discord-bot?

Ja. Verschillende providers hebben gratis tiers die werken met het openai-pakket voor Python. FreeLLMAPI combineert ze achter één sleutel, zodat een drukke bot de limieten van veel providers kan gebruiken.

Kan ik een gratis AI-Telegram-bot maken?

Ja. Gebruik python-telegram-bot voor de bot en een OpenAI-compatibele gratis API voor de antwoorden. De code op deze pagina is volledig.

Hoe voorkom ik dat mijn AI-bot ratelimieten bereikt?

Antwoord alleen op vermeldingen of commando's, beperk elke gebruiker tot één verzoek elke paar seconden, houd de geschiedenis kort en voeg sleutels van meer providers toe.

Waarom krijgt mijn Discord-bot lege berichtinhoud?

De intentie Message Content staat uit. Zet hem aan in de Developer Portal op het tabblad bot, en stel in de code intents.message_content = True in.

Wat gebeurt er als alle gratis modellen hun limiet hebben bereikt?

FreeLLMAPI geeft fout 429 terug met een header Retry-After. De botcode vangt die op en vraagt de gebruiker het later opnieuw te proberen.

Gerelateerde gidsen

Bronnen

Alle gidsen · Bekijk alle gratis modellen