Gratis AI Discord-bots in 2026

Als je zoekt naar “free AI Discord bot”, vind je tientallen opties. Sommige zijn echt gratis. De meeste zijn dat niet, in elk geval niet op de manier die je misschien verwacht. Dit artikel zet uiteen wat er werkelijk beschikbaar is, wat de afwegingen zijn en wat “gratis” echt kost wanneer AI-inferentie een rol speelt.

Waarom “gratis AI” ingewikkeld is

Een LLM draaien kost geld. Elke keer dat een gebruiker een bericht stuurt en een antwoord krijgt, betaalt iemand voor de rekenkracht. Voor een gehoste API zoals OpenAI of Anthropic betaal je per token. Voor een self-hosted model betaal je in hardware, elektriciteit en onderhoudstijd. Daar is geen ontkomen aan: inferentie heeft een marginale kost die niet nul is.

Wanneer een dienst een “gratis AI-bot” aanbiedt, geldt een van de volgende zaken:

1. Je betaalt de inferentiekosten rechtstreeks (bijvoorbeeld door je eigen API key te gebruiken).
2. De dienst neemt de kosten op zich en verdient die terug via betaalde tiers, advertenties of dataverzameling.
3. Je draait inferentie zelf op je eigen hardware met een open-sourcemodel.
4. De gratis tier heeft limieten bij een laag volume, zodat de provider zijn blootstelling aan rekenkosten beperkt.

Begrijpen welke van deze situaties op een bot van toepassing is, is de sleutel om te beoordelen of die bot echt bij je use case past.

De drie categorieën gratis AI Discord-bots

1. Self-hosted open-source bots (echt gratis, jij levert hardware)

Dit is de enige optie waarbij geen derde partij je gebruikslimieten bepaalt. Je draait lokaal (of op een VPS) een open-source LLM, koppelt die aan Discord via een bot die je zelf schrijft of forkt, en beheert alles zelf.

Typische stack:

• Ollama voor lokale modelserving
• discord.py of discord.js voor de Discord-bot
• Een model zoals Llama 3.1 8B, Mistral 7B of Gemma 2 9B

Wat je krijgt:

• Geen kosten per bericht, behalve elektriciteit
• Volledige controle over het model, de system prompt en data
• Geen rate limits die door een derde partij worden opgelegd (alleen Discords eigen API-limieten gelden)
• Lokale modelverwerking: inferentie blijft op je machine, terwijl Discord de berichten nog steeds transporteert en opslaat

Wat je opgeeft:

• Je hebt hardware nodig. Een model met 7B parameters op redelijke snelheid draaien vereist een GPU met ten minste 8 GB VRAM, of een moderne Mac met unified memory. CPU-inferentie werkt, maar is traag (meerdere seconden per antwoord voor een 7B-model).
• Je onderhoudt de infrastructuur. Updates, herstarts, monitoring en schijfruimte voor model weights zijn jouw verantwoordelijkheid.
• De modelkwaliteit is lager dan die van frontiermodellen. Llama 3.1 8B is capabel, maar het is geen GPT-4o of Claude Sonnet. Voor eenvoudige Q&A en informele gesprekken werkt het prima. Voor genuanceerd redeneren of complexe gesprekken met meerdere beurten schiet het tekort.
• Geen ingebouwde kennisbank, analytics of handoff-functies. Je bouwt zelf wat je nodig hebt.

Minimale hardwarevereisten voor gangbare modellen:

(Snelheden zijn bij benadering, gemeten op een RTX 4090. Gekwantiseerde varianten gebruiken minder geheugen tegen een kleine kwaliteitskost.)

2. Freemium managed services (gratis tier met limieten)

Dit zijn producten waarbij iemand anders de AI en de botinfrastructuur host. Je configureert de bot via een webdashboard. De gratis tier geeft je beperkt gebruik, voor meer betaal je.

Voorbeelden:

Het Free plan van Quickchat AI laat je testen zonder creditcard. De Discord-integratie is beschikbaar op elke tier, zodat je je bot kunt koppelen en met echte gebruikers kunt testen voordat je je vastlegt. Koppelen kost één klik: open in External Apps Discord en klik op Add to your Discord server, kies daarna de server waaraan je de bot wilt toevoegen. Betaalde abonnementen beginnen met Starter voor $9/mo, of $8/mo bij jaarlijkse facturatie.

Het belangrijkste voordeel van managed services is dat je functies krijgt bovenop pure LLM-inferentie: kennisbanken opgebouwd uit je documenten en website, gespreksanalytics (sentimentanalyse, onderwerpherkenning), multi-channel inzet (dezelfde agent werkt op je website, WhatsApp, Slack en Discord) en menselijke handoff voor gevallen die de AI niet kan oplossen. Dit vanaf nul bouwen bovenop een self-hosted model is een aanzienlijk engineeringproject.

MEE6 is vooral een bot voor moderatie en engagement. De AI-chatfuncties zitten achter het premiumabonnement ($11.99/mo begin 2026). De gratis tier omvat leveling, basiscommando’s voor moderatie en welkomstberichten, maar geen AI-gestuurde gesprekken.

Botpress heeft een gratis tier met 2,000 inkomende berichten per maand over alle kanalen. Het biedt een visuele flow builder en ondersteunt aangepaste LLM-configuraties. De setup is echter complexer dan Quickchat voor een eenvoudige Discord-bot, omdat Botpress vooral is ontworpen voor gestructureerde gespreksflows in plaats van open chat.

3. BYO API key bots (jij betaalt de LLM-provider)

Een derde categorie: open-source bots die op een server draaien, maar voor inferentie een commerciële API aanroepen (OpenAI, Anthropic, Google, enzovoort). Je levert je API key. De botcode zelf is gratis, maar je betaalt per token aan de modelprovider.

Voorbeelden op GitHub:

• GPT Discord Bot (het officiële voorbeeld van OpenAI)
• Diverse communitybots gebouwd met discord.py + de OpenAI Python SDK

Kosten per bericht met commerciële API’s (bij benadering, begin 2026):

*Uitgaande van ~500 inputtokens en ~200 outputtokens per berichtuitwisseling, zonder gespreksgeschiedenis. Als gespreksgeschiedenis wordt meegenomen, schalen inputkosten lineair met de contextlengte.

Bij 1,000 berichten per maand met GPT-4o mini zou je ongeveer $0.30 uitgeven. Bij 10,000 berichten per maand ongeveer $3.00. Deze bedragen lijken klein totdat je gespreksgeschiedenis meerekent: als elk bericht de volledige gesprekscontext bevat (bijvoorbeeld 10 eerdere beurten), groeit het aantal inputtokens per bericht van ~500 naar ~5,000, waardoor inputkosten 10x stijgen en de totale kosten toenemen.

Kostenvergelijking tussen benaderingen

De volgende tabel schat maandelijkse kosten bij verschillende berichtvolumes. “Self-hosted” gaat uit van een kleine VPS of bestaande hardware. “BYO API Key” gebruikt de prijzen van GPT-4o mini. “Managed” gebruikt de prijzen van Quickchat AI als referentie.

Opmerkingen bij de self-hosted kolom: de bandbreedte hangt af van of je een VPS met alleen CPU gebruikt (goedkoper, maar tragere antwoorden) of een GPU-instance. Hetzner biedt CPU-VPS-instances voor ongeveer $5-10/mo waarop een gekwantiseerd 7B-model kan draaien, al zullen antwoordtijden 5-15 seconden zijn. GPU-cloudinstances (bijvoorbeeld van Lambda, RunPod of Vast.ai) beginnen rond $0.20-0.50/hr voor één GPU, wat neerkomt op $150-360/mo als ze 24/7 draaien. Voor incidenteel gebruik kunnen spot instances of serverless GPU-providers dit verlagen.

De BYO API key kolom toont een bereik omdat kosten sterk afhangen van of je gespreksgeschiedenis in elke request opneemt. De ondergrens is single-turn (geen geschiedenis), de bovengrens is multi-turn met ~10 berichten context.

De managed service kolom weerspiegelt de prijzen van Quickchat per juni 2026. Deze abonnementen bevatten functies zoals kennisbankbeheer, analytics en multi-channel ondersteuning die in de andere twee benaderingen niet bestaan zonder extra engineeringwerk.

Een snelle self-hosted setup: Python + discord.py + Ollama

Hieronder staat een minimaal werkend voorbeeld van een Discord-bot die Ollama gebruikt voor lokale inferentie. Dit vereist dat Ollama is geïnstalleerd en draait, en dat een model is opgehaald (bijvoorbeeld ollama pull llama3.1:8b).

Vereisten

1. Python 3.10+
2. Ollama geïnstalleerd en actief (curl -fsSL https://ollama.com/install.sh | sh)
3. Een opgehaald model: ollama pull llama3.1:8b
4. Een Discord-bottoken (maak er een aan in de Discord Developer Portal)
5. De bot toegevoegd aan je server met de rechten Send Messages en Read Message History

Dependencies installeren

pip install discord.py aiohttp

Botcode

import discord
import aiohttp
import json

DISCORD_TOKEN = "your-bot-token-here"
OLLAMA_URL = "http://localhost:11434/api/chat"
MODEL = "llama3.1:8b"
SYSTEM_PROMPT = "Je bent een behulpzame assistent in een Discord-server. Houd antwoorden beknopt."

# Sla gespreksgeschiedenis per kanaal op (in memory, wordt gereset bij herstart)
conversations: dict[int, list[dict]] = {}
MAX_HISTORY = 10  # Bewaar de laatste 10 berichten per kanaal

intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)


async def query_ollama(channel_id: int, user_message: str) -> str:
    """Stuur een bericht naar Ollama en geef het antwoord terug."""
    if channel_id not in conversations:
        conversations[channel_id] = []

    conversations[channel_id].append({"role": "user", "content": user_message})

    # Kort geschiedenis in om onbegrensde geheugengroei te voorkomen
    if len(conversations[channel_id]) > MAX_HISTORY:
        conversations[channel_id] = conversations[channel_id][-MAX_HISTORY:]

    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + conversations[channel_id]

    payload = {
        "model": MODEL,
        "messages": messages,
        "stream": False,
    }

    async with aiohttp.ClientSession() as session:
        async with session.post(OLLAMA_URL, json=payload) as resp:
            if resp.status != 200:
                return f"Ollama gaf status {resp.status} terug"
            data = await resp.json()
            reply = data["message"]["content"]

    conversations[channel_id].append({"role": "assistant", "content": reply})
    return reply


@client.event
async def on_ready():
    print(f"Ingelogd als {client.user}")


@client.event
async def on_message(message: discord.Message):
    # Negeer eigen berichten
    if message.author == client.user:
        return

    # Reageer alleen wanneer de bot wordt genoemd
    if client.user not in message.mentions:
        return

    # Verwijder de mention uit het bericht
    content = message.content.replace(f"<@{client.user.id}>", "").strip()
    if not content:
        return

    async with message.channel.typing():
        reply = await query_ollama(message.channel.id, content)

    # Discord heeft een limiet van 2000 tekens per bericht
    if len(reply) > 2000:
        for i in range(0, len(reply), 2000):
            await message.reply(reply[i:i+2000])
    else:
        await message.reply(reply)


client.run(DISCORD_TOKEN)

Dit is ongeveer 60 regels code en geeft je een werkende AI-bot die reageert wanneer hij wordt genoemd. De bot houdt gespreksgeschiedenis per kanaal in memory bij (verloren bij herstart) en handelt Discords berichtlimiet van 2,000 tekens af.

Wat deze minimale bot mist

De code hierboven werkt voor tests en kleine servers. Voor alles daarbuiten loop je tegen verschillende problemen aan die productiebots moeten afhandelen:

• Persistente gespreksgeschiedenis. De in-memory dict gaat verloren wanneer het proces herstart. Een productiebot zou gesprekken opslaan in Redis of een database.
• Rate limiting. Discord staat 5 berichten per 5 seconden per kanaal toe. Als je bot populair is, heb je een queue nodig.
• Gelijktijdige requests. Ollama verwerkt standaard één request tegelijk. Meerdere gebruikers die tegelijk berichten sturen, komen in de wachtrij. Je kunt meerdere Ollama-instances achter een load balancer draaien, of Ollama’s optie OLLAMA_NUM_PARALLEL gebruiken (beschikbaar sinds v0.1.33).
• Foutafhandeling en retries. Ollama kan crashen, geen geheugen meer hebben of ongeldige antwoorden teruggeven. De bot moet al deze situaties netjes afhandelen.
• Beheer van context window. De instelling MAX_HISTORY = 10 is naïef. Een betere aanpak telt tokens en kort in zodat alles binnen het context window van het model past (standaard 8,192 tokens voor Llama 3.1 8B, configureerbaar tot 128K met kwaliteitsverlies bij langere contexten).
• Thread-ondersteuning. Op Discord vinden botgesprekken vaak plaats in threads. Het afhandelen van threadcreatie en geschiedenis per thread vereist extra logica.
• Kennisbank / RAG. Als je wilt dat de bot vragen beantwoordt over de documentatie van je project, heb je een retrieval-augmented generation setup nodig: embed je docs, sla embeddings op in een vectordatabase en haal relevante chunks op voordat je ze naar de LLM stuurt.

Technische valkuilen

Rate limits van de Discord API

Discord legt rate limits op meerdere niveaus op:

• Limieten per route: Elk API-endpoint heeft zijn eigen rate limit, teruggegeven in responseheaders (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset).
• Globale limiet: 50 requests per seconde over alle endpoints.
• Berichtlimiet per kanaal: 5 berichten per 5 seconden per kanaal.
• Gateway-limieten: 120 gateway events per 60 seconden.

De library discord.py handelt de meeste hiervan automatisch af door requests in de wachtrij te zetten wanneer je een limiet bereikt. Als je bot echter tegelijk in veel servers of kanalen zit, kun je nog steeds de globale limiet bereiken. Op dat punt moet je kijken naar sharding (de serververbindingen van de bot verdelen over meerdere gatewayverbindingen).

Voor bots die de intent MESSAGE_CONTENT gebruiken (vereist om berichttekst te lezen), vereist Discord dat je je bot verifieert als die in meer dan 100 servers zit. Dit betekent dat je een beschrijving moet indienen van wat je bot doet en goedkeuring van Discord moet krijgen.

Afwegingen in modelkwaliteit

Het verschil tussen kleine open-sourcemodellen en commerciële frontiermodellen is kleiner dan twee jaar geleden, maar het bestaat nog steeds. Hier is een grove vergelijking voor gangbare Discord-bottaken:

Als je Discord-bot voor een gamingcommunity is en vooral informele chat en eenvoudige opzoekvragen afhandelt, werkt een lokaal 8B-model goed. Als de bot voor klantenservice is, waar nauwkeurigheid belangrijk is, wordt het kwaliteitsverschil een echt probleem. In character blijven gaat ook minder over het model dan over de setup: hoe je een roleplay AI-chatbot bouwt die in character blijft laat zien hoe ver een persona prompt en een canon-kennisbank je brengen, zelfs met een standaardmodel.

Beheer van context window

Dit is de meest onderschatte technische uitdaging bij Discord-bots. Discord-gesprekken bestaan van nature uit meerdere beurten: gebruikers sturen veel korte berichten, en de bot moet onthouden wat eerder in het gesprek is gezegd.

Elke keer dat de bot antwoordt, moet hij eerdere gespreksgeschiedenis in de prompt opnemen. Dit betekent:

• Het aantal inputtokens groeit lineair met de gesprekslengte.
• Voor API-gebaseerde bots groeien de kosten ook lineair.
• Voor lokale modellen groeit de inferentietijd met de contextlengte (kwadratisch in attention-berekening, al helpen optimalisaties zoals Flash Attention).
• Op een gegeven moment overschrijdt het gesprek het context window van het model en heb je een strategie nodig: afkappen vanaf het begin, oudere berichten samenvatten of een nieuw gesprek starten.

Een praktische aanpak is een rollend venster van de laatste N berichten behouden en, als het gesprek lang is geweest, een korte samenvatting van eerdere context vooraf toevoegen. Dit vereist een extra LLM-call om de samenvatting te genereren, maar houdt de kosten per bericht begrensd.

Privacy-implicaties

Dit verschilt sterk per benadering:

• Self-hosted: AI-inferentie blijft op je hardware, dus jij beheert de logs en bewaartermijnen van de modelverwerking. Discord transporteert en bewaart berichten nog steeds, lokale inferentie maakt niet het hele gesprek lokaal.
• BYO API Key: Berichten worden naar de API-provider gestuurd (OpenAI, Anthropic, enzovoort). Controleer hun beleid voor databewaring. Begin 2026 stelt OpenAI dat ze standaard niet trainen op API-data, en Anthropic heeft een vergelijkbaar beleid. Berichten gaan echter wel via hun servers.
• Managed services: Berichten worden verwerkt door de serviceprovider. Controleer hun privacybeleid en verwerkersovereenkomsten. Voor bedrijven die gebruikersdata in de EU verwerken, is GDPR-compliance hier relevant. Quickchat AI verwerkt data bijvoorbeeld in de EU en biedt een DPA voor zakelijke klanten.

Voor een informele Discord-server is privacy meestal geen primaire zorg. Voor een bedrijf dat een Discord-bot gebruikt voor klantenservice, is het de moeite waard om precies te begrijpen waar gespreksdata wordt opgeslagen en wie er toegang toe heeft.

Self-hosted versus managed: total cost of ownership

De vergelijking van pure rekenkosten uit de tabel hierboven vertelt maar een deel van het verhaal. De total cost of ownership omvat ook engineeringtijd.

Wat je zelf bouwt met een self-hosted bot:

• Botcode en deployment
• Opslag van gespreksgeschiedenis
• Beheer van context window
• Foutafhandeling en monitoring
• Kennisbank / RAG-pipeline (indien nodig)
• Analytics en logging
• Multi-channel ondersteuning (indien nodig)

Conservatief geschat kost het bouwen van een self-hosted AI Discord-bot van productiekwaliteit met gespreksgeschiedenis, een kennisbank en basisanalytics 40-80 uur engineeringtijd voor een ervaren developer. Het onderhoud (modelupdates, dependency-updates, debugging, monitoring) vraagt doorlopend extra tijd.

Wat je out of the box krijgt met een managed service:

• Bothosting en uptimebeheer
• Kennisbank opgebouwd uit je website, docs en bestanden
• Gespreksanalytics (sentiment, onderwerpen, beoordelingen)
• Multi-channel deployment (dezelfde agent op Discord, website, WhatsApp, Slack, enzovoort)
• Menselijke handoff wanneer de AI niet kan helpen
• AI Actions (aangepaste API-calls geactiveerd door gesprekscontext), inclusief moderatieacties zoals timeout, kick en ban

De vraag is of de maandelijkse kosten van de managed service lager zijn dan de opportunity cost van je engineeringtijd. Voor een solo developer die een hobby-Discord-server draait, is self-hosting met Ollama waarschijnlijk de juiste keuze. Voor een bedrijf dat Discord gebruikt als klantgericht supportkanaal, valt de rekensom meestal uit in het voordeel van een managed service, omdat de functies rond de kern-LLM (analytics, kennisbank, handoff) de bot echt bruikbaar maken. De AI-ticketbotgids bouwt precies die combinatie end-to-end op het Free plan, zodat je het alternatief kunt afprijzen tegen iets concreets.

Samenvatting

Er is geen universeel “beste” gratis AI Discord-bot. De juiste keuze hangt af van wat “gratis” voor jou betekent:

• Als je geen doorlopende kosten wilt en hardware beschikbaar hebt, host dan zelf met Ollama en een open-sourcemodel. Je beheert lokale modelverwerking en de databewaring daarvan, terwijl Discord berichten nog steeds transporteert en opslaat. Je levert modelkwaliteit in vergeleken met frontiermodellen en neemt al het engineeringwerk op je.
• Als je met echte gebruikers wilt testen voordat je iets betaalt, kun je met het Free plan van Quickchat AI zonder creditcard starten. De Discord-integratie werkt op het Free plan, en betaalde abonnementen beginnen bij $9/mo.
• Als je frontiermodelkwaliteit wilt en het beheren van API keys geen probleem vindt, geeft een BYO API key bot je dat met lage kosten per bericht (vooral met GPT-4o mini of Gemini Flash). Je moet nog steeds de botcode hosten en alle functies buiten pure chat zelf bouwen.
• Als je productiefuncties nodig hebt (kennisbank, analytics, handoff, multi-channel), is een managed service de snelste route. Evalueer op basis van het berichtvolume dat je verwacht en de functies die je echt nodig hebt.

Het woord “gratis” in “gratis AI Discord-bot” draagt veel betekenis. De rekenkracht kost altijd iets. De vraag is wie ervoor betaalt, en wat je ervoor terugkrijgt (of opgeeft).

Voor een bredere vergelijking van alle AI Discord-bots (niet alleen gratis bots), zie onze roundup Beste AI Discord-bots in 2026. Als je server specifiek een supportkanaal is, laat AI Discord Ticket Bot zien hoe je antwoorden uit je docs geeft en de rest escaleert naar private ticket threads.