Ein Discord-Bot-Statistik-Panel zeigt dir auf einen Blick, in wie vielen Servern dein Bot ist, wie viele Nutzer er bedient und welche Befehle am häufigsten ausgeführt werden. Diese Metriken sind unbezahlbar, sowohl um das Wachstum deines Bots zu verfolgen als auch um zu verstehen, welche Funktionen die Leute wirklich nutzen. In diesem Artikel zeige ich Schritt für Schritt, wie du Nutzungsmetriken mit discord.js erfasst, speicherst und anzeigst – beginnend mit der grundlegendsten: der Serveranzahl.
Welche Metriken solltest du verfolgen?
Statt jede mögliche Zahl zu sammeln, konzentriere dich auf jene, die Entscheidungen leiten. Für die meisten Bots reichen diese Kernmetriken:
- Server- (Guild-)Anzahl — die Gesamtzahl der Server, in denen dein Bot ist. Das direkteste Zeichen für Wachstum.
- Gesamtzahl der Nutzer — das ungefähre Publikum, das du erreichst (die Summe der Mitgliederzahlen).
- Befehlsnutzung — wie oft jeder Slash-Befehl ausgeführt wurde.
- Aktive Server — Server, die in den letzten 24 Stunden mindestens einen Befehl ausgeführt haben.
- Shard-Zustand — sobald der Bot wächst, die Latenz und Uptime jedes Shards.
Achte auf den Datenschutz: Speichere niemals sensible Daten wie Nachrichteninhalte. Für Statistiken genügen Zahlen; der Inhalt wird nicht benötigt.
Die Serveranzahl in Echtzeit auslesen
Die grundlegendste Metrik, die Serveranzahl, kommt in discord.js direkt aus client.guilds.cache. Du kannst sie auslesen, wenn der Bot bereit ist, und sie aktualisieren, wann immer der Bot einem Server beitritt oder ihn verlässt:
const { Client, GatewayIntentBits, Events } = require('discord.js');
const client = new Client({ intents: [GatewayIntentBits.Guilds] });
client.once(Events.ClientReady, (c) => {
const serverCount = c.guilds.cache.size;
const userCount = c.guilds.cache.reduce(
(acc, g) => acc + g.memberCount, 0
);
console.log(`${c.user.tag} in ${serverCount} Servern, ~${userCount} Nutzer`);
});
client.on(Events.GuildCreate, (guild) => {
console.log(`Beigetreten: ${guild.name} (${guild.memberCount})`);
});
client.on(Events.GuildDelete, (guild) => {
console.log(`Verlassen: ${guild.name}`);
});
client.login(process.env.DISCORD_TOKEN);Das Feld memberCount liefert die Gesamtmitgliederzahl eines Servers, ohne dass ein zusätzlicher Intent oder das Abrufen der vollständigen Mitgliederliste nötig ist – damit ist es ideal und schnell, um deine Nutzerreichweite zu schätzen.
Befehlsnutzung erfassen
Um zu erfahren, welche Befehle wertvoll sind, musst du jede Ausführung an einen persistenten Ort schreiben. Du kannst in deinem Slash-Befehl-Handler einen einfachen Zähler führen. Im Beispiel unten schieben wir jeden Befehlsaufruf in eine Datenbank:
client.on(Events.InteractionCreate, async (interaction) => {
if (!interaction.isChatInputCommand()) return;
// Befehl ausführen...
const command = commands.get(interaction.commandName);
if (command) await command.execute(interaction);
// Metrik erfassen (ohne zu blockieren)
recordUsage(interaction.commandName, interaction.guildId)
.catch(console.error);
});Das Schreiben der Metrik darf die Antwort des Befehls nicht verlangsamen. Deshalb übergeben wir es ohne await an eine separate Funktion und fangen den Fehler ab. Für die Speicherung eignet sich SQLite hervorragend für kleine Bots, während PostgreSQL oder Redis (für schnelle Zähler) mit zunehmendem Wachstum sinnvoll werden.
Die Daten speichern: ein einfaches Schema
Ein schlichtes Layout mit zwei Tabellen reicht für Statistiken meist aus. Eine Tabelle für Momentaufnahmen (Snapshots) im Zeitverlauf, eine für Befehlszähler:
CREATE TABLE stat_snapshots (
id INTEGER PRIMARY KEY,
server_count INTEGER NOT NULL,
user_count INTEGER NOT NULL,
recorded_at TEXT NOT NULL DEFAULT (datetime('now'))
);
CREATE TABLE command_usage (
command TEXT NOT NULL,
guild_id TEXT,
used_at TEXT NOT NULL DEFAULT (datetime('now'))
);Jede Stunde oder einmal täglich eine Zeile in die Snapshot-Tabelle einzufügen, ermöglicht es dir, die Serveranzahl über die Zeit darzustellen. Das geht mit einem einfachen Intervall:
const ONE_HOUR = 60 * 60 * 1000;
setInterval(() => {
const servers = client.guilds.cache.size;
const users = client.guilds.cache.reduce(
(a, g) => a + g.memberCount, 0
);
db.run(
'INSERT INTO stat_snapshots (server_count, user_count) VALUES (?, ?)',
[servers, users]
);
}, ONE_HOUR);Das Panel ausliefern: eine kleine API und UI
Sobald du die Daten erfasst, genügt ein winziger HTTP-Server, um sie in einem Panel anzuzeigen. Mit Express kannst du einen Endpunkt bereitstellen, der JSON zurückgibt, und ihn im Frontend als einfache Karten rendern:
const express = require('express');
const app = express();
app.get('/api/stats', (req, res) => {
res.json({
servers: client.guilds.cache.size,
users: client.guilds.cache.reduce((a, g) => a + g.memberCount, 0),
uptime: Math.floor(client.uptime / 1000),
ping: client.ws.ping,
});
});
app.listen(3000);Im Frontend kannst du diesen Endpunkt alle paar Sekunden per fetch abrufen und die Zahlen aktualisieren, um ein Live-Gefühl zu erzeugen. Für ein historisches Diagramm speist du einfach die Daten aus stat_snapshots in eine Liniendiagramm-Bibliothek wie Chart.js ein. Ist das Panel öffentlich, schütze alle Schreib-Endpunkte und gib nur schreibgeschützte Statistiken aus.
Summen bei einem geshardeten Bot zählen
Wenn dein Bot wächst und auf Sharding umsteigt, sieht jeder Shard nur seine eigenen Server. Für eine genaue Summe musst du über alle Shards aggregieren. Die Klasse ShardingManager von discord.js macht das einfach:
const total = await client.shard.fetchClientValues('guilds.cache.size');
const serverCount = total.reduce((acc, n) => acc + n, 0);Dieser Aufruf fragt jeden Shard ab und gibt ein Array zurück, das du summierst. Für berechnete Werte wie die Nutzerzahl verwendest du broadcastEval. Du musst Sharding nicht früh einrichten, aber dein Panel von Anfang an um die Aggregation herum zu entwerfen, macht die spätere Migration deutlich reibungsloser.
Häufige Fragen
Kann ich die Serveranzahl im Status des Bots anzeigen?
Ja. Mit client.user.setActivity kannst du einen Text wie „in X Servern“ anzeigen. Aktualisiere ihn bei Join-/Leave-Events oder alle paar Minuten; zu häufige Aktualisierung kann an Rate-Limits stoßen.
Ist die Nutzerzahl exakt?
memberCount liefert die Gesamtmitglieder, die ein Server meldet, aber dieselbe Person kann in mehreren deiner Server sein; es ist also eine „Reichweiten“-Schätzung und keine Zählung eindeutiger Nutzer. Eindeutige Nutzer zu zählen ist weitaus aufwändiger und meist unnötig.
Welche Datenbank sollte ich wählen?
Bis zu einigen hundert Servern reicht SQLite mehr als aus und erfordert keine Einrichtung. Mit dem Wachstum wechselst du zu PostgreSQL und nutzt Redis für sehr hochfrequente Zähler.
Möchtest du ein professionelles Statistik-Panel für deinen Bot? Von der Serveranzahl bis zur Befehlsanalyse baue ich die Metrik-Pipeline und gestalte das Live-Panel. Kontaktiere mich und beginne, deinen Bot mit Daten zu steuern.