Warum einen Discord-Bot selbst hosten?

Discord hat sich von der reinen Gamer-Kommunikation zur zentralen Plattform für Communities, Entwickler-Teams, Hobby-Projekte und ganze Unternehmen entwickelt. Über 200 Millionen aktive Nutzer monatlich tauschen sich dort in Millionen von Servern aus. Ein eigener Bot automatisiert Moderation, Begrüßungen, Musikwiedergabe, Ticketsysteme, Umfragen, Level-Systeme und tausend andere Anwendungsfälle. Doch bevor der erste node index.js auf dem Bildschirm erscheint, steht die zentrale Frage: Wo läuft der Bot 24/7 zuverlässig?

Es gibt im Wesentlichen drei Optionen:

• Replit / Glitch / Railway Free Tier: Schnell eingerichtet, aber mit harten Limits (Cold Starts, CPU-Throttling, Sleep-Mode nach Inaktivität). Für ernsthafte Bots indiskutabel.
• Discord Bot Hosting (Discloud, PloxHost, PebbleHost): Speziallösungen mit Node.js-Vorinstallation, oft 2–5 Euro pro Monat. Praktisch für Einsteiger, aber unflexibel bei Datenbanken, persistenten Volumes, eigenem Domain-Setup und tiefgreifender Konfiguration.
• Eigener VPS (Hetzner, Netcup, Contabo, DigitalOcean): Volle Root-Rechte, freie Wahl von Datenbank, Prozessmanager, Reverse Proxy und CI/CD. Du zahlst 3–6 Euro pro Monat und kannst auf demselben VPS weitere Dienste wie Portainer, n8n oder Vaultwarden betreiben.

Ein eigener VPS bietet dir als Entwickler oder Community-Manager entscheidende Vorteile: Keine Limits bei Befehlsaufrufen, freier Datenbank-Wechsel zwischen SQLite, PostgreSQL und MongoDB, persistente Logs, eigene Domain mit HTTPS, vollständige Kontrolle über Sicherheits-Updates und das Deployment. Die Einrichtung dauert 30–60 Minuten, danach läuft der Bot zuverlässig im Hintergrund. Genau das zeigen wir dir in dieser Komplettanleitung.

Discord Bot Grundlagen: Developer Portal, Application & Bot-Token

Der Einstieg beginnt im offiziellen Discord Developer Portal. Logge dich mit deinem Discord-Account ein und klicke auf „New Application". Vergib einen sprechenden Namen (z. B. „MeinCommunityBot") und akzeptiere die Discord-API-Nutzungsbedingungen.

Im linken Menü findest du die wichtigsten Bereiche:

• General Information: App-Beschreibung, Icon, Tags – wichtig für die Auffindbarkeit im Discord-App-Verzeichnis.
• Bot: Hier wird der eigentliche Bot-User erzeugt. Klicke auf „Add Bot" und notiere dir den Token – das ist der geheime Schlüssel, mit dem dein Skript Befehle an Discord sendet. Behandle ihn wie ein Passwort: niemals in Git committen, niemals öffentlich posten.
• OAuth2 → URL Generator: Erzeugt den Einladungslink, mit dem du den Bot auf deinen Server einlädst. Wähle mindestens die Scopes bot und applications.commands sowie die Permissions, die dein Bot wirklich braucht (Administrator nur, wenn unbedingt nötig – sonst besser granulare Rechte wie Send Messages, Embed Links, Manage Roles).
• Installation: Discord erlaubt seit 2024 auch die Installation in User-Accounts – für reine Slash-Command-Bots ein interessanter Pfad.

Speichere den Bot-Token in einer .env-Datei (niemals in index.js direkt) und lade sie mit dem Paket dotenv. Im Abschnitt zur Sicherheit gehen wir darauf noch ausführlich ein.

Vorbereitung: Den richtigen VPS mieten

Ein Discord-Bot ist kein ressourcenhungriger Dienst. Für die meisten Bots reicht bereits der kleinste VPS-Tarif – vorausgesetzt, die CPU-Architektur ist aktuell und die Anbindung gut. Unsere Empfehlung für 2026:

• CPU: Mindestens 1 vCPU (besser 2 vCPUs, wenn du nebenbei Datenbanken oder Webhooks betreibst). AMD EPYC oder Intel Xeon der aktuellen Generation.
• RAM: 1 GB Minimum, 2 GB empfohlen. Node.js belegt je nach Bot-Größe 80–250 MB, plus 100–300 MB für PM2, optional 200–500 MB für PostgreSQL.
• Speicher: 20 GB NVMe-SSD reichen für ein Jahr Logs. Für Musik-Bots mit lokalem Cache 50 GB sinnvoll.
• Betriebssystem: Ubuntu 24.04 LTS (Long Term Support bis 2029) oder Debian 12 Bookworm. Beide liefern Node.js 22 in den offiziellen Repositories.
• Standort: Frankfurt, Amsterdam oder Helsinki für niedrige Latenzen zu Discord (Hauptsitz in den USA, aber EU-Routing ist effizient).

Günstige Anbieter für Deutschland: Hetzner Cloud (CX22 mit 2 vCPU, 4 GB RAM, 40 GB SSD für 4,85 Euro/Monat), Netcup (ab 2,99 Euro/Monat) und Contabo (sehr günstig, etwas weniger Performance). Achte auf IPv6 inklusive, DDoS-Schutz und tägliche Snapshot-Backups. Auf unserem Anbieter-Vergleich findest du eine ausführliche Tabelle.

Node.js 22 installieren und discord.js einrichten

Nach dem SSH-Login auf deinem VPS installierst du Node.js 22 über das offizielle NodeSource-Repository. Damit bekommst du die aktuelle LTS-Version mit nativer Test-Runner-, WebSocket- und Performance-Verbesserungen:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs build-essential
node -v   # sollte v22.x.x ausgeben
npm -v

Lege dir nun ein Projektverzeichnis an und initialisiere npm:

mkdir ~/discord-bot && cd ~/discord-bot
npm init -y
npm install discord.js dotenv
npm install --save-dev nodemon

Discord.js v14 ist die aktuelle Hauptversion. Sie unterstützt vollständig die neue Slash-Command-API, Buttons, Select-Menus, Modals und Context-Menüs. Die package.json sieht am Ende so aus:

{
  "name": "mein-discord-bot",
  "version": "1.0.0",
  "description": "Mein Community-Bot auf Node.js 22 & discord.js v14",
  "main": "src/index.js",
  "type": "module",
  "scripts": {
    "start": "node src/index.js",
    "dev": "nodemon src/index.js"
  },
  "engines": {
    "node": ">=22.0.0"
  },
  "dependencies": {
    "discord.js": "^14.16.0",
    "dotenv": "^16.4.5"
  },
  "devDependencies": {
    "nodemon": "^3.1.7"
  }
}

Die .env-Datei legst du mit touch .env && nano .env an:

DISCORD_TOKEN=DEIN-BOT-TOKEN-HIER
DISCORD_CLIENT_ID=DEINE-APPLICATION-ID
DISCORD_GUILD_ID=DEINE-SERVER-ID
DATABASE_URL=file:./data/bot.db
PORT=3000
NODE_ENV=production
LOG_LEVEL=info

Erstelle nun src/index.js – die minimale Bot-Datei:

import { Client, GatewayIntentBits, Events } from 'discord.js';
import 'dotenv/config';

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
    GatewayIntentBits.GuildMembers
  ]
});

client.once(Events.ClientReady, c => {
  console.log(`✅ Eingeloggt als ${c.user.tag}`);
  c.user.setActivity('Hostazar Tutorial läuft');
});

client.on(Events.MessageCreate, async message => {
  if (message.author.bot) return;
  if (message.content === '!ping') {
    return message.reply(`🏓 Pong! Latenz: ${client.ws.ping}ms`);
  }
});

client.login(process.env.DISCORD_TOKEN);

Teste das Setup lokal mit npm run dev. Sobald im Terminal „Eingeloggt als …" erscheint, schreibe !ping in deinen Discord-Server – der Bot antwortet mit der Latenz.

Datenbank: SQLite vs. PostgreSQL mit Prisma ORM

Jeder ernsthafte Bot speichert dauerhaft Daten: User-Level, Warnungen, Ticket-Verläufe, Custom-Commands, Rollen-Konfigurationen. Dafür brauchst du eine Datenbank. Die zwei wichtigsten Optionen:

SQLite ist eine dateibasierte Datenbank, die in Node.js ohne Server auskommt. Perfekt für Bots mit bis zu 100.000 Datensätzen, einzelne Guilds und Hobby-Projekte. Backups erledigst du durch Kopieren der bot.db-Datei. PostgreSQL ist die professionelle Wahl, wenn du Multi-Guild-Support, Transaktionen, Replikation und Hochverfügbarkeit brauchst. Du betreibst sie auf demselben VPS oder in einem Managed-Service (z. B. Hetzner Managed Postgres).

Wir empfehlen den Prisma ORM als Abstraktionsschicht. Er erzeugt typsichere Datenbank-Client-Klassen aus einem deklarativen Schema, unterstützt Migrationen und funktioniert mit beiden Datenbanken identisch. Installation:

npm install prisma @prisma/client
npx prisma init --datasource-provider sqlite
# Für PostgreSQL: --datasource-provider postgresql

Das prisma/schema.prisma-File könnte so aussehen:

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite"
  url      = env("DATABASE_URL")
}

model User {
  id          String   @id @default(cuid())
  discordId   String   @unique
  xp          Int      @default(0)
  level       Int      @default(1)
  warnings    Int      @default(0)
  joinedAt    DateTime @default(now())
}

model GuildConfig {
  id              String  @id @default(cuid())
  guildId         String  @unique
  welcomeChannel  String?
  modLogChannel   String?
  ticketCategory  String?
}

model Ticket {
  id          String   @id @default(cuid())
  guildId     String
  userId      String
  channelId   String   @unique
  status      String   @default("open")
  createdAt   DateTime @default(now())
  closedAt    DateTime?
}

Mit npx prisma migrate dev --name init erzeugst du die Migration, mit npx prisma generate den typsicheren Client. In deinem Bot-Code nutzt du ihn so:

import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

const user = await prisma.user.upsert({
  where: { discordId: message.author.id },
  update: { xp: { increment: 10 } },
  create: { discordId: message.author.id, xp: 10 }
});

24/7-Betrieb sicherstellen: PM2, systemd, Docker

Ein Discord-Bot muss laufen, auch wenn dein SSH-Fenster geschlossen ist. Dafür gibt es drei bewährte Methoden:

PM2 ist der populärste Node.js-Prozessmanager. Er startet den Bot, restartet ihn bei Crashes, sammelt Logs und kann Cluster-Mode (mehrere Worker-Prozesse) konfigurieren. Installation:

sudo npm install -g pm2
pm2 start src/index.js --name discord-bot
pm2 startup systemd    # generiert systemd-Service
pm2 save               # speichert aktuelle Prozessliste
pm2 logs discord-bot   # Live-Logs anzeigen
pm2 monit              # CPU/RAM-Live-Monitoring

systemd ist die native Linux-Variante und die robusteste Lösung für Produktionsumgebungen. Eine Service-Datei unter /etc/systemd/system/discord-bot.service:

[Unit]
Description=Discord Bot
After=network.target postgresql.service

[Service]
Type=simple
User=botuser
WorkingDirectory=/home/botuser/discord-bot
ExecStart=/usr/bin/node src/index.js
Restart=always
RestartSec=5
EnvironmentFile=/home/botuser/discord-bot/.env

[Install]
WantedBy=multi-user.target

Aktivieren mit sudo systemctl enable --now discord-bot. Status prüfen: systemctl status discord-bot.

Docker ist die Königsklasse, besonders wenn du den Bot zusammen mit PostgreSQL, Traefik und weiteren Services betreibst. Eine docker-compose.yml:

services:
  bot:
    build: .
    container_name: discord-bot
    restart: unless-stopped
    env_file: .env
    depends_on:
      - postgres
    networks: [botnet]

  postgres:
    image: postgres:16-alpine
    container_name: discord-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: discordbot
      POSTGRES_USER: bot
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - pgdata:/var/lib/postgresql/data
    networks: [botnet]

volumes:
  pgdata:

networks:
  botnet:
    driver: bridge

In Verbindung mit Portainer und Docker Compose hast du ein wartungsfreies Setup, das mit docker compose pull && docker compose up -d aktualisiert wird. Die Datenbank wird automatisch in einem persistenten Volume gespeichert.

HTTPS-Webhooks für Slash Commands & Interaktionen

Seit 2022 verlangt Discord für alle „Interactions" (Slash Commands, Buttons, Modals) eine öffentliche HTTPS-URL, die innerhalb von 3 Sekunden antworten muss. Selbst wenn du discord.js im klassischen Gateway-Modus nutzt, ist ein Webhook-Endpoint für interaktive Components und langlaufende Aufgaben sinnvoll. Express oder Fastify sind die gängigsten Frameworks:

import express from 'express';
const app = express();
app.use(express.json({ verify: verifyDiscordRequest }));

app.post('/interactions', async (req, res) => {
  const interaction = req.body;
  if (interaction.type === InteractionType.Ping) {
    return res.send({ type: InteractionResponseType.Pong });
  }
  if (interaction.type === InteractionType.ApplicationCommand) {
    return res.send({
      type: InteractionResponseType.ChannelMessageWithSource,
      data: { content: 'Hallo vom Webhook-Endpoint! 🚀' }
    });
  }
  res.status(400).send('Unbekannter Interaction-Typ');
});

app.listen(process.env.PORT || 3000, () => {
  console.log(`🌍 Webhook-Endpoint lauscht auf Port ${process.env.PORT}`);
});

Wichtig: Hinter verifyDiscordRequest steckt die Validierung der ED25519-Signatur aus dem X-Signature-Ed25519-Header mit deinem DISCORD_PUBLIC_KEY. discord.js liefert mit @discordjs/verify eine fertige Library dafür.

Vor deinen VPS packst du am besten einen Traefik- oder Nginx-Reverse-Proxy mit Let's Encrypt. So bekommst du automatisch gültige TLS-Zertifikate, HTTP/2 und saubere URLs wie https://bot.deinedomain.de/interactions. Diese URL trägst du im Developer Portal unter „Interactions Endpoint URL" ein.

Sicherheit: Token-Schutz, .env-Dateien, Rate Limits

Sicherheit ist bei selbst gehosteten Bots kein Nice-to-have, sondern Pflicht. Discord hat 2024 verschärft, wie mit Tokens und Permissions umzugehen ist. Die wichtigsten Regeln:

• Token niemals committen: Lege eine .gitignore an, die .env, node_modules/ und data/*.db ausschließt. Verwende Git-Secrets oder Pre-Commit-Hooks, die versehentliche Commits blocken.
• Token rotieren: Discord erlaubt das Regenerieren des Tokens im Developer Portal. Mache das mindestens halbjährlich und sofort, wenn der Verdacht auf ein Leck besteht.
• .env-Berechtigungen: chmod 600 .env – nur dein User darf lesen und schreiben. Auf dem VPS niemals als root laufen lassen, sondern einen dedizierten Service-User anlegen.
• Rate Limits respektieren: discord.js v14 handhabt HTTP-429-Antworten automatisch mit Backoff. Überwache die globalen Shards-Limits, um nicht temporär gebannt zu werden.
• Intents minimal: Aktiviere im Developer Portal nur die Privileged Intents, die du wirklich brauchst (MessageContent, GuildMembers). Discord verlangt für jeden Intent einen triftigen Grund und prüft das manuell.
• Input-Validierung: Slash-Commands liefern JSON, aber User können bösartige Strings in Formular-Felder eingeben. Validiere und escape alle Eingaben, bevor du sie in eine Datenbank schreibst oder in Embeds anzeigst.
• Container-Isolation: Betreibst du den Bot in Docker, setze read_only: true, cap_drop: ["ALL"] und ein internes Docker-Netzwerk. So hat der Prozess selbst im Worst-Case keinen Zugriff auf andere Container.

Ergänzend empfehlen wir unseren VPS-Sicherheitsguide und Linux-Server-Hardening – beide enthalten Checklisten für SSH, Firewall, Fail2ban und automatische Updates.

Beispielprojekte: Musik-, Moderations-, Ticket-Bot & Custom Commands

Nach dem lauffähigen Grundgerüst kannst du dich an konkreten Features versuchen. Vier typische Bot-Typen aus der Praxis:

Musik-Bot mit discord.js/voice und @discordjs/opus (bzw. sodium-native für bessere Performance): Spielt YouTube-, SoundCloud- und Spotify-Links ab, verwaltet eine Queue, unterstützt Pause/Skip/Loop. Achtung: Spotify-Playback benötigt libspotify oder den Lavalink-Umweg, da die offizielle Spotify-API kein Audio-Streaming für Drittanbieter erlaubt.

Moderations-Bot mit Slash Commands /ban, /kick, /mute, /warn und /purge. Speichere Warnungen in der Prisma-Datenbank, protokolliere Aktionen in einem Mod-Log-Channel, und richte Auto-Mod für Spam, Caps-Lock und verbotene Wörter ein. Eine gute Vorlage ist der beliebte Carla-Bot-Klon oder discord.js-Commando als Inspiration.

Ticket-Bot: User erstellen per /ticket einen privaten Channel, der Bot postet ein Eingabeformular, ein Mod-Team übernimmt. Beim Schließen wird der Channel archiviert, ein Transkript als HTML gespeichert und optional ins Postfach des Nutzers gemailt.

Custom-Commands-Bot: Mit einer dynamischen CustomCommand-Tabelle kannst du Usern erlauben, eigene Antworten auf Trigger-Wörter zu definieren – perfekt für Meme-Server. Setze Rate-Limits (max. 5 Befehle pro User pro Minute), um Missbrauch zu verhindern.

Wenn du weitere Ideen suchst: n8n lässt sich wunderbar als Brücke zwischen Discord und externen Diensten nutzen – etwa um Support-Tickets direkt in dein Helpdesk zu spiegeln.

Logging & Monitoring: Winston, Pino, Sentry

Logs sind das Rückgrat jeder Fehlersuche. In Produktion willst du strukturierte Logs (JSON), rotierende Dateien und zentrale Aggregation. Drei Tools, die wir empfehlen:

Winston ist der Klassiker unter den Node.js-Loggern, mit Transports für Konsole, Datei, HTTP, Syslog und mehr:

import winston from 'winston';
const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'logs/error.log', level: 'error' }),
    new winston.transports.File({ filename: 'logs/combined.log' })
  ]
});
logger.info('Bot gestartet', { guilds: client.guilds.cache.size });

Pino ist 3–5x schneller als Winston und liefert von Haus aus schöne strukturierte Logs. Empfohlen für Performance-kritische Bots:

import pino from 'pino';
const logger = pino({
  transport: { target: 'pino-pretty', options: { colorize: true } }
});

Sentry fängt unbehandelte Exceptions, sendet E-Mail-Alerts und gruppiert Fehler nach Häufigkeit. Ideal für Bots mit tausenden Usern. Installation:

npm install @sentry/node
import * as Sentry from '@sentry/node';
Sentry.init({ dsn: process.env.SENTRY_DSN, tracesSampleRate: 0.2 });
process.on('unhandledRejection', err => Sentry.captureException(err));

Für die Infrastruktur-Überwachung kombinierst du das mit Uptime Kuma und Prometheus + Grafana. So weißt du jederzeit über CPU, RAM, Netzwerk und Discord-Latenz Bescheid.

Updates einspielen ohne Downtime: PM2 reload & Blue-Green Deployment

Ein professioneller Bot darf bei Updates nicht offline gehen. PM2 bietet dafür den reload-Befehl, der Worker-Prozesse graceful nacheinander neu startet:

git pull origin main
npm ci --production
npx prisma migrate deploy
pm2 reload discord-bot

Im Cluster-Mode (pm2 start src/index.js -i max) wird jeder Worker einzeln durchgerollt, sodass der Bot dauerhaft erreichbar bleibt. Discord-Websocket-Verbindungen werden sauber neu aufgebaut.

Für Docker-Setups nutzt du Blue-Green Deployment:

docker compose pull
docker compose up -d --no-deps --scale bot=2 bot
sleep 10
docker compose up -d --no-deps --scale bot=1 bot
docker image prune -f

Während des Rollouts laufen zwei Bot-Container parallel, Discord verteilt die Shard-Verbindungen automatisch. Nach dem Health-Check wird die alte Instanz gestoppt. Diese Methode ist Zero-Downtime und eignet sich besonders für Bots, die in mehreren Gilden gleichzeitig laufen.

Automatisieren kannst du das Ganze mit GitHub Actions, die bei einem git push in den main-Branch automatisch den Build, die Tests, das Docker-Image und das Deployment auf dem VPS anstoßen.

Kostenrechnung: VPS, Domain & optionale Premium-Features

Was kostet ein selbst gehosteter Discord-Bot wirklich? Hier eine ehrliche Rechnung für 2026:

• VPS (Hetzner CX22): 4,85 Euro/Monat (2 vCPU, 4 GB RAM, 40 GB SSD). Reicht für Bot + Datenbank + 2–3 Nebenprojekte. Alternativ Raspberry Pi 5 8GB für 90 Euro einmalig, ~3 Euro Strom/Jahr.
• Domain (optional): 8–12 Euro/Jahr bei Namecheap oder Porkbun. Nur nötig, wenn du HTTPS-Webhooks mit eigener URL betreiben willst.
• Backups (empfohlen): Hetzner Storage Box 1 TB für 3,81 Euro/Monat, alternativ Backblaze B2 mit 6 USD/TB pro Monat.
• Monitoring (optional): Uptime Kuma Self-Hosted (kostenlos), Sentry Free Tier (5.000 Events/Monat), Better Stack (9 USD/Monat für mehr Komfort).
• Premium-Bot-Features (optional): Spotify-API für Musik-Bots (kostenlos, aber Rate-Limited), Genius-API für Lyrics (kostenlos), YouTube Data API v3 (10.000 Units/Tag kostenlos).

Im Schnitt liegst du zwischen 5 und 15 Euro pro Monat – weniger als ein einziges Espresso pro Tag, dafür mit kompletter Kontrolle, freier Skalierbarkeit und keinerlei fremden Datenkrümel-Cookies. Hosting, das hält was es verspricht.

Fazit: Discord-Bot selbst hosten lohnt sich 2026 mehr denn je

Einen Discord-Bot auf einem eigenen VPS zu hosten ist 2026 einfacher und günstiger denn je. Dank ausgereifter Frameworks wie discord.js v14, leistungsstarken Tools wie PM2, Docker und Prisma sowie günstigen VPS-Tarifen ab 3 Euro pro Monat steht einem professionellen Setup nichts mehr im Weg. Du behältst 100 % Kontrolle über deine Daten, deine Slash-Commands, deine Datenbank und deine Verfügbarkeit.

Die wichtigsten Schritte nochmal zusammengefasst:

1. Discord Application + Bot-Token im Developer Portal erstellen
2. Ubuntu-VPS mieten, Node.js 22 installieren
3. discord.js-Projekt aufsetzen, .env schützen
4. Prisma-Datenbank mit SQLite oder PostgreSQL anbinden
5. PM2 oder systemd für 24/7-Betrieb konfigurieren
6. Optional: Docker, Traefik, Webhooks, Monitoring

Mit dieser Anleitung hast du eine Blaupause für einen produktionsreifen Discord-Bot, der locker mit 50, 500 oder 50.000 Usern skaliert. Wenn du weitere Fragen hast, schau in unsere anderen DevOps-Tutorials – speziell Docker Compose, VPS absichern und Backup-Strategien ergänzen diesen Guide perfekt.

Viel Erfolg beim Coden deines Bots – und möge dein VPS stets online sein! 🚀