Zum Inhalt springen
+90 850 303 07 52 [email protected]
Support Kundenbereich
Bei ausgewählten Hosting-Paketen mit Jahreslaufzeit und VDS-Paketen mit 3 Monaten Laufzeit: .com / .com.tr-Domain im ersten Jahr kostenlos · Pakete ansehen

Anleitungen

Schritt-für-Schritt-Anleitungen, um Ihren eigenen Server, Gameserver und Ihre Website einzurichten und zu betreiben – vom Team, das unsere Infrastruktur in Istanbul betreibt.

Discord Bot

Support-Ticket-Bot mit Discord.js v14 erstellen

26 August 2026 14 Min. Lesezeit Aktualisiert:
Diesen Beitrag teilen

Ein Support-Ticket-Bot ermöglicht es Mitgliedern, per Klick auf einen Button einen Kanal zu öffnen, den nur sie selbst und das Support-Team sehen können; ist das Gespräch beendet, wird der Kanal geschlossen und der Verlauf als Datei im Log-Kanal abgelegt. In dieser Anleitung erstellen Sie mit discord.js v14 ein Panel mit dem Button „Ticket öffnen“, einen Ticket-Kanal mit passenden Berechtigungen, eine Sperre gegen ein zweites Ticket, einen Button zum Schließen und ein Transkript (Gesprächsprotokoll) als Klartext; im letzten Schritt bauen Sie dasselbe System mit privaten Threads (Unterhaltungen innerhalb eines Kanals) auf. Weitere Bot-Anleitungen finden Sie auf der Seite Discord-Bot-Anleitungen.

Bevor Sie beginnen

  • Ein lauffähiges Bot-Projekt: Die Beispiele verwenden die Struktur aus der Anleitung zum Einrichten eines Bots von Grund auf: commands/utility, index.js, deploy-commands.js, die Datei .env mit dem Token sowie die Skripte npm start / npm run deploy. Der Code wurde auf Grundlage der Dokumentation von discord.js 14.27.0 geschrieben.
  • Button-Grundlagen: customId, die 3-Sekunden-Regel und dauerhafte Panels werden in der Anleitung zu Buttons und Auswahlmenüs erklärt und hier nicht wiederholt.
  • Verwaltungsrechte: Sie müssen Rollen, Kategorien und Kanäle erstellen und die Berechtigungen der Bot-Rolle ändern können. Zum Kopieren von IDs sollte der Entwicklermodus (Developer Mode) aktiviert sein.
  • Ein Ort, an dem der Bot dauerhaft läuft: Solange der Bot offline ist, reagiert das Panel nicht. Der Code ist unter Windows und Linux identisch; Sie können auf Ihrem Computer entwickeln und den Bot auf einem VDS betreiben. Die HanHosting-Pakete Discord Bot VDS bieten 4 CPU, 2–4 GB RAM und 30–40 GB NVMe-Speicher.

1. Support-Rolle, Kategorie und Log-Kanal vorbereiten

  1. Support-Rolle: Die Rolle des Teams, das die Tickets beantwortet (z. B. „Support-Team“).
  2. Ticket-Kategorie: Die Kategorie, in der neue Ticket-Kanäle geöffnet werden. Entziehen Sie der Bot-Rolle hier nicht die Berechtigung zum Ansehen. Eine Kategorie fasst höchstens 50 Kanäle.
  3. Log-Kanal: Der Textkanal, in dem die Transkripte landen. Deaktivieren Sie für @everyone „View Channel“ (Kanal ansehen); aktivieren Sie für die Support-Rolle und die Bot-Rolle die Berechtigungen „View Channel“, „Send Messages“ (Nachrichten senden) und „Attach Files“ (Dateien anhängen).

Kopieren Sie die IDs aller drei über das Rechtsklickmenü und tragen Sie sie in die Datei .env unter der vorhandenen Zeile DISCORD_TOKEN ein:

DESTEK_ROL_ID=111111111111111111
TALEP_KATEGORI_ID=222222222222222222
TALEP_LOG_KANAL_ID=333333333333333333

So läuft derselbe Code auf einem anderen Server, wenn Sie nur diese Datei ändern. Auch das Token steht nur hier; die Datei muss in der Liste .gitignore bleiben.

2. Bot-Berechtigungen und Intents einrichten

Die Bot-Rolle benötigt serverweit folgende Berechtigungen: ViewChannel, SendMessages, ReadMessageHistory, AttachFiles und ManageChannels (in der deutschen Oberfläche lauten die Namen anders). Die Anfrage zum Erstellen eines Kanals erfordert ManageChannels. Außerdem erlaubt Discord dem Bot in Berechtigungsüberschreibungen (Permission Overwrites) nur solche Berechtigungen zu erteilen oder zu entziehen, die er selbst besitzt; um dem Ticket-Ersteller AttachFiles geben zu können, muss auch der Bot diese Berechtigung haben. Vergeben Sie kein Administrator; gelangt das Token in falsche Hände, ist der Schaden sonst größer. Die vollständige Liste steht in der Discord-Dokumentation zu Berechtigungen.

Im Code genügt der Intent (Ereignisberechtigung) GatewayIntentBits.Guilds: Button-Interaktionen benötigen keinen zusätzlichen Intent, Kanalereignisse und Cache kommen über diesen Intent. Aktivieren Sie für das Transkript im Developer Portal auf der Seite „Bot“ den Schalter Message Content Intent; ist er deaktiviert, sind in Nachrichten, die der Bot per REST abruft, der von Benutzern geschriebene Text, Anhänge und Embeds leer. Laut Discord ist diese HTTP-Einschränkung unabhängig von der Intent-Liste im Code; Sie müssen den Intent MessageContent nicht in den Code aufnehmen.

3. Den Panel-Befehl schreiben

commands/utility/talep-paneli.js sendet eine Nachricht mit dem Button „Ticket öffnen“ in den Kanal, in dem der Befehl verwendet wird. setDefaultMemberPermissions zeigt den Befehl standardmäßig nur Mitgliedern mit der Berechtigung „Manage Server“ (Server verwalten); wie Befehle definiert werden, erklärt die Anleitung zu Slash-Befehlen.

const {
  ActionRowBuilder, ButtonBuilder, ButtonStyle, MessageFlags,
  PermissionFlagsBits, SlashCommandBuilder,
} = require('discord.js');

module.exports = {
  data: new SlashCommandBuilder()
    .setName('talep-paneli')
    .setDescription('Sendet das Support-Ticket-Panel in diesen Kanal.')
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild),
  async execute(interaction) {
    const buton = new ButtonBuilder()
      .setCustomId('talep-ac')
      .setLabel('Ticket öffnen')
      .setStyle(ButtonStyle.Primary);
    await interaction.channel.send({
      content: 'Klicken Sie auf den Button, um Support zu erhalten; es wird ein Ticket geöffnet, das nur Sie und das Support-Team sehen.',
      components: [new ActionRowBuilder().addComponents(buton)],
    });
    await interaction.reply({ content: 'Panel gesendet.', flags: MessageFlags.Ephemeral });
  },
};

Da das Panel als eigene Nachricht gesendet wird, braucht der Bot im Panel-Kanal die Berechtigung zum Senden von Nachrichten.

4. Den Code zum Öffnen von Tickets schreiben

Legen Sie im Stammverzeichnis des Projekts die Datei talep.js an. Der erste Teil enthält die gemeinsamen Einstellungen und die Funktion, die den Ticket-Kanal öffnet:

// talep.js - Support-Tickets öffnen, schließen und Transkript
const {
  ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle,
  ChannelType, MessageFlags, PermissionFlagsBits, ThreadAutoArchiveDuration,
} = require('discord.js');

const { DESTEK_ROL_ID, TALEP_KATEGORI_ID, TALEP_LOG_KANAL_ID } = process.env;
const ONEK = 'talep-sahibi:';
const IZINLER = [
  PermissionFlagsBits.ViewChannel,
  PermissionFlagsBits.SendMessages,
  PermissionFlagsBits.ReadMessageHistory,
  PermissionFlagsBits.AttachFiles,
];
const acilanlar = new Set(); // Benutzer, deren Ticket gerade erstellt wird
const kapananlar = new Set(); // Kanäle, die gerade geschlossen werden

function kapatSatiri() {
  return new ActionRowBuilder().addComponents(
    new ButtonBuilder()
      .setCustomId('talep-kapat')
      .setLabel('Ticket schließen')
      .setStyle(ButtonStyle.Danger),
  );
}

async function talepAc(interaction) {
  const { guild, user } = interaction;
  await interaction.deferReply({ flags: MessageFlags.Ephemeral });

  const mevcut = guild.channels.cache.find((k) => k.topic === ONEK + user.id);
  if (mevcut) return interaction.editReply(`Sie haben bereits ein offenes Ticket: ${mevcut}`);
  if (acilanlar.has(user.id)) return interaction.editReply('Ihr Ticket wird vorbereitet, bitte warten Sie.');
  acilanlar.add(user.id);

  try {
    const ad = user.username.toLowerCase().replace(/[^a-z0-9_-]/g, '') || user.id;
    const kanal = await guild.channels.create({
      name: `talep-${ad}`,
      type: ChannelType.GuildText,
      parent: TALEP_KATEGORI_ID,
      topic: ONEK + user.id,
      reason: `Support-Ticket: ${user.username}`,
      permissionOverwrites: [
        { id: guild.roles.everyone.id, deny: [PermissionFlagsBits.ViewChannel] },
        { id: user.id, allow: IZINLER },
        { id: DESTEK_ROL_ID, allow: IZINLER },
        { id: interaction.client.user.id, allow: IZINLER },
      ],
    });
    await kanal.send({
      content: `${user}, Ihr Ticket wurde geöffnet. Beschreiben Sie Ihr Problem ausführlich; das Support-Team antwortet in diesem Kanal.`,
      components: [kapatSatiri()],
    });
    await interaction.editReply(`Ihr Ticket wurde geöffnet: ${kanal}`);
  } catch (hata) {
    console.error(hata);
    await interaction.editReply('Das Ticket konnte nicht geöffnet werden; bitte informieren Sie das Team.');
  } finally {
    acilanlar.delete(user.id);
  }
}
  • Zuerst bestätigen: deferReply bestätigt die Interaktion sofort; auch wenn das Erstellen des Kanals länger als 3 Sekunden dauert, verfällt die Interaktion nicht.
  • Sperre gegen ein zweites Ticket: Die ID des Erstellers wird in das Kanalthema (topic) geschrieben und vor einem neuen Ticket im Cache gesucht. Da sich der Cache beim Start des Bots neu füllt, funktioniert die Prüfung auch nach einem Neustart; die Menge acilanlar fängt einen zweiten Klick ab, der eintrifft, bevor der Kanal erstellt ist. Ändern Sie das Kanalthema nicht von Hand.
  • Berechtigungen: Discord berechnet Kanalberechtigungen zuerst aus den Überschreibungen für @everyone, dann für Rollen und zuletzt für Mitglieder. Wer „View Channel“ nicht hat, kann auch die übrigen Berechtigungen im Kanal nicht nutzen; deshalb ist der eigene Eintrag des Bots zwingend erforderlich.
  • Kanalname: Aus dem Benutzernamen werden alle Zeichen außer Kleinbuchstaben, Ziffern, _ und - entfernt; die Prüfung erfolgt über die ID, nicht über den Namen.

5. Schließen-Button und Transkript hinzufügen

Fügen Sie den Teil zum Schließen am Ende derselben Datei hinzu:

async function mesajlariTopla(kanal, enFazla = 1000) {
  const mesajlar = [];
  let before;
  while (mesajlar.length < enFazla) {
    const parti = await kanal.messages.fetch({ limit: 100, before, cache: false });
    mesajlar.push(...parti.values());
    if (parti.size < 100) break;
    before = parti.last().id;
  }
  return mesajlar.reverse(); // von alt nach neu
}

function satir(m) {
  const ekler = m.attachments.map((e) => e.url).join(' ');
  return `[${m.createdAt.toISOString()}] ${m.author.username}: ${m.content} ${ekler}`.trimEnd();
}

function sahipBul(kanal) {
  if (kanal.isThread()) return kanal.name.startsWith('talep-') ? kanal.name.split('-').pop() : null;
  return kanal.topic?.startsWith(ONEK) ? kanal.topic.slice(ONEK.length) : null;
}

async function talepKapat(interaction) {
  const kanal = interaction.channel;
  const sahipId = sahipBul(kanal);
  const yetkili = interaction.member.roles.cache.has(DESTEK_ROL_ID);
  if (!sahipId || (!yetkili && interaction.user.id !== sahipId)) {
    return interaction.reply({
      content: 'Dieses Ticket kann nur sein Ersteller oder das Support-Team schließen.',
      flags: MessageFlags.Ephemeral,
    });
  }
  if (kapananlar.has(kanal.id)) {
    return interaction.reply({ content: 'Das Ticket wird bereits geschlossen.', flags: MessageFlags.Ephemeral });
  }
  kapananlar.add(kanal.id);

  try {
    await interaction.deferReply();
    const metin = (await mesajlariTopla(kanal)).map(satir).join('\n');
    const dosya = new AttachmentBuilder(Buffer.from(metin, 'utf8'), { name: `${kanal.name}.txt` });
    const kayit = await interaction.guild.channels.fetch(TALEP_LOG_KANAL_ID);
    await kayit.send({
      content: `${kanal.name} geschlossen. Ersteller: <@${sahipId}>, geschlossen von: <@${interaction.user.id}>`,
      files: [dosya],
      allowedMentions: { parse: [] },
    });
    await interaction.editReply('Transkript gespeichert, das Ticket wird geschlossen.');
    if (kanal.isThread()) {
      await kanal.setLocked(true);
      await kanal.setArchived(true);
      kapananlar.delete(kanal.id);
    } else {
      setTimeout(() => {
        kanal.delete(`Ticket geschlossen: ${interaction.user.username}`)
          .catch(console.error)
          .finally(() => kapananlar.delete(kanal.id));
      }, 5_000);
    }
  } catch (hata) {
    console.error(hata);
    kapananlar.delete(kanal.id);
    await interaction.editReply('Das Ticket konnte nicht geschlossen werden; prüfen Sie den Log-Kanal und die Bot-Berechtigungen.');
  }
}

module.exports = { talepAc, talepKapat };
  • Berechtigung: Ein Ticket können nur sein Ersteller und Mitglieder der Support-Rolle schließen; alle anderen erhalten einen Hinweis, den nur sie selbst sehen. Die Menge kapananlar verhindert Doppelklicks; da auch deferReply innerhalb von try steht, bleibt die Sperre bei einem Fehler nicht bestehen.
  • Grenzen beim Abrufen von Nachrichten: Eine Anfrage zum Auflisten von Nachrichten liefert höchstens 100 Nachrichten auf einmal (Standard 50). Die Schleife geht in jeder Runde mit before von der ältesten Nachricht des Stapels aus zurück und stoppt bei 1.000 Nachrichten (10 Anfragen); reverse() sortiert die Nachrichten von alt nach neu. before, after und around können nicht zusammen verwendet werden. Fehlt dem Bot ReadMessageHistory, gibt Discord eine leere Liste zurück.
  • Dateien und Löschen: Anhänge werden nur als Adresse eingetragen; Discord liefert diese Adressen mit einer zeitlich begrenzten Signatur, nach einiger Zeit lassen sie sich nicht mehr öffnen. Wenn Sie Anhänge aufbewahren müssen, laden Sie sie herunter, bevor der Kanal gelöscht wird. allowedMentions:{ parse: [] } verhindert, dass die Erwähnungen in der Log-Nachricht Benachrichtigungen auslösen. Das Löschen eines Kanals lässt sich nicht rückgängig machen; der Code löscht erst, wenn das Transkript den Log-Kanal erreicht hat.

6. Buttons in index.js einbinden und testen

Binden Sie oben in index.js die Datei talep.js ein und setzen Sie die Button-Prüfung an den Anfang des Event-Listeners, der die Slash-Befehle verarbeitet:

const { talepAc, talepKapat } = require('./talep.js');

client.on(Events.InteractionCreate, async (interaction) => {
  if (interaction.isButton()) {
    try {
      if (interaction.customId === 'talep-ac') await talepAc(interaction);
      else if (interaction.customId === 'talep-kapat') await talepKapat(interaction);
    } catch (hata) {
      console.error(hata);
    }
    return;
  }

  if (!interaction.isChatInputCommand()) return;
  // ... der bestehende Code für die Slash-Befehle bleibt unverändert
});

Ohne try/catch bleibt ein Fehler, der bei einer abgelaufenen Interaktion geworfen wird, eine unbehandelte Promise-Ablehnung; Node.js behandelt diese standardmäßig als nicht abgefangene Ausnahme, und der Prozess kann beendet werden. Registrieren Sie den Befehl und starten Sie den Bot (in Windows PowerShell und unter Linux identisch):

npm run deploy
npm start

Verwenden Sie in einem Kanal den Befehl /talep-paneli. Klicken Sie mit einem zweiten Konto zweimal schnell hintereinander auf „Ticket öffnen“; es darf nur ein Kanal entstehen. Prüfen Sie, dass ein drittes Konto den Kanal nicht sieht und das Transkript beim Schließen im Log-Kanal landet. Läuft der Bot auf dem VDS mit PM2 (Anleitung zum 24/7-Betrieb), führen Sie nach einem Update pm2 restart discord-bot aus.

7. Alternative: Tickets als private Threads öffnen

Ein privater Thread ist eine Unterhaltung unterhalb eines Textkanals, die nur hinzugefügte Mitglieder und Personen mit der Berechtigung „Manage Threads“ (Threads verwalten) sehen können. Wenn Sie Tickets als private Threads im Panel-Kanal öffnen, stoßen Sie nicht an die Kanalgrenzen, und geschlossene Tickets bleiben im Archiv erhalten. Vorbereitung:

  • Aktivieren Sie im Panel-Kanal für @everyone „View Channel“ und „Send Messages in Threads“ (Nachrichten in Threads senden); deaktivieren Sie „Send Messages“, „Create Public Threads“ (Öffentliche Threads erstellen) und „Create Private Threads“ (Private Threads erstellen). In Threads hat die Berechtigung SendMessages keine Wirkung.
  • Geben Sie der Support-Rolle in diesem Kanal „Manage Threads“; die Rolle sieht alle privaten Threads und kann gesperrte Threads wieder öffnen.
  • Fügen Sie der Bot-Rolle die Berechtigungen CreatePrivateThreads, SendMessagesInThreads und ManageThreads hinzu.

Fügen Sie die folgende Funktion in talep.js ein und ändern Sie die letzte Zeile in module.exports = { talepAc, talepAcKonu, talepKapat };; ergänzen Sie in index.js die Zeile mit require um den Namen talepAcKonu und leiten Sie den Button talep-ac an diese Funktion weiter:

async function talepAcKonu(interaction) {
  const { channel, user } = interaction; // Textkanal, in dem sich das Panel befindet
  await interaction.deferReply({ flags: MessageFlags.Ephemeral });

  const mevcut = channel.threads.cache.find((k) => !k.archived && sahipBul(k) === user.id);
  if (mevcut) return interaction.editReply(`Sie haben bereits ein offenes Ticket: ${mevcut}`);
  if (acilanlar.has(user.id)) return interaction.editReply('Ihr Ticket wird vorbereitet, bitte warten Sie.');
  acilanlar.add(user.id);

  try {
    const konu = await channel.threads.create({
      name: `talep-${user.username}-${user.id}`,
      type: ChannelType.PrivateThread,
      invitable: false,
      autoArchiveDuration: ThreadAutoArchiveDuration.OneWeek,
      reason: `Support-Ticket: ${user.username}`,
    });
    await konu.members.add(user.id);
    await konu.send({ content: `${user}, Ihr Ticket wurde geöffnet. Beschreiben Sie Ihr Problem ausführlich.`, components: [kapatSatiri()] });
    await interaction.editReply(`Ihr Ticket wurde geöffnet: ${konu}`);
  } catch (hata) {
    console.error(hata);
    await interaction.editReply('Das Ticket konnte nicht geöffnet werden; bitte informieren Sie das Team.');
  } finally {
    acilanlar.delete(user.id);
  }
}

Über die Benutzer-ID am Ende des Thread-Namens findet die Funktion sahipBul den Ticket-Ersteller; der Schließen-Code aus Schritt 5 sperrt und archiviert den Thread, statt ihn zu löschen. invitable: false verhindert, dass Nicht-Moderatoren weitere Mitglieder zum Thread hinzufügen. Alle Thread-Operationen beschreibt die discord.js-Anleitung zu Threads.

EigenschaftTicket-KanalPrivater Thread
Wer sieht esFreigegebene Mitglieder und RollenHinzugefügte Mitglieder und Inhaber der Berechtigung „Manage Threads“
Mengenbegrenzung50 Kanäle pro Kategorie, 500 pro ServerZählt nicht zur Kanalgrenze; für aktive Threads gibt es eine eigene Grenze (die Dokumentation nennt keine Zahl)
Zusätzliche Bot-BerechtigungManageChannelsCreatePrivateThreads, SendMessagesInThreads, ManageThreads
SchließenKanal wird gelöscht, nicht rückgängig zu machenWird gesperrt und archiviert, der Verlauf bleibt erhalten
Bei InaktivitätBleibt offenWird nach der gewählten Dauer (1 Stunde–7 Tage) archiviert; ist er nicht gesperrt, öffnet ihn eine neue Nachricht wieder

Übersicht der Berechtigungen und Einstellungen

Ort der EinstellungWert
Bot-Rolle (serverweit)ViewChannel, SendMessages, ReadMessageHistory, AttachFiles, ManageChannels; bei der Thread-Methode zusätzlich CreatePrivateThreads, SendMessagesInThreads, ManageThreads
Ticket-Kanal@everyone: ViewChannel deaktiviert. Ticket-Ersteller, Support-Rolle und Bot: ViewChannel, SendMessages, ReadMessageHistory, AttachFiles aktiviert
Log-Kanal@everyone: „View Channel“ deaktiviert. Support-Rolle und Bot: „View Channel“, „Send Messages“, „Attach Files“ aktiviert
Developer Portal → BotMessage Content Intent aktiviert (für den Nachrichtentext im Transkript)
CodeGatewayIntentBits.Guilds genügt
.envDISCORD_TOKEN, DESTEK_ROL_ID, TALEP_KATEGORI_ID, TALEP_LOG_KANAL_ID

Häufige Fehler

  • Das Ticket wird nicht geöffnet, in der Konsole steht DiscordAPIError[50013]: Missing Permissions: Der Bot-Rolle fehlt ManageChannels oder eine der in den Überschreibungen vergebenen Berechtigungen (z. B. AttachFiles); fügen Sie die fehlende Berechtigung der Bot-Rolle hinzu.
  • Der Kanal wird geöffnet, aber die Begrüßungsnachricht erscheint nicht, in der Konsole steht DiscordAPIError[50001]: Missing Access: Der Bot kann den von ihm geöffneten Kanal nicht sehen; möglicherweise wurde der Bot-Eintrag in der Liste der Überschreibungen gelöscht. Tritt der Fehler beim Senden des Transkripts auf, kann der Bot den Log-Kanal nicht sehen.
  • Kanäle werden außerhalb der Kategorie oder gar nicht geöffnet: Eine ID in .env fehlt oder ist falsch. Die Werte werden nur beim Start gelesen; starten Sie den Bot nach einer Änderung der Datei neu.
  • Maximum number of guild channels reached (500) (30013) oder Kategorie voll: Der Server hat 500 Kanäle oder die Kategorie 50 Kanäle erreicht. Schließen Sie alte, offen gebliebene Tickets, verwenden Sie eine zweite Kategorie oder wechseln Sie zur Thread-Methode aus Schritt 7.
  • Benutzernachrichten im Transkript sind leer: Message Content Intent ist deaktiviert; da diese Einschränkung nicht für die eigenen Nachrichten des Bots und für Nachrichten gilt, die den Bot erwähnen, erscheinen in der Datei nur diese mit Inhalt.
  • In der Konsole steht 40060 Interaction has already been acknowledged: Ein zweiter Prozess mit demselben Token läuft (z. B. die Kopie auf Ihrem Computer); beide Prozesse erhalten denselben Klick, aber nur einer kann antworten. Beenden Sie einen davon. Zur Meldung „This interaction failed“ und zu 10062 lesen Sie die Button-Anleitung.
  • Bei der Thread-Methode erscheint 160005 Thread is locked: Es wurde eine Nachricht an ein gesperrtes Ticket gesendet; die Sperre kann nur aufheben, wer „Manage Threads“ besitzt.

Häufig gestellte Fragen

Werden offene Tickets beeinträchtigt, wenn der Bot neu startet?

Nein. Da Buttons im Ereignis interactionCreate über ihre customId verarbeitet werden, funktionieren alte Panels und Schließen-Buttons weiter; weil sich der Kanal-Cache beim Start neu füllt, bleibt auch die Prüfung auf ein zweites Ticket intakt. Die beiden kurzen Sperren, die während eines Vorgangs gehalten werden, werden zurückgesetzt; fällt ein Neustart in die 5-sekündige Wartezeit beim Schließen, wird der Kanal nicht gelöscht – schließen Sie das Ticket dann erneut.

Wie speichere ich Ticketnummern und den Verlauf?

Kanalthema und Cache kennen nur offene Tickets. Für dauerhafte Daten wie eine fortlaufende Nummer (z. B. talep-0001), Öffnungs- und Schließzeitpunkt oder das Teammitglied, das geschlossen hat, verwenden Sie eine Datenbank; die Einrichtung beschreibt die Anleitung Datenbanken in Discord-Bots.

Stoße ich beim Erstellen von Transkripten an Rate Limits?

Bei normaler Nutzung nicht. Discord wendet auf alle Bots ein globales Limit von 50 Anfragen pro Sekunde sowie separate Limits pro Endpunkt an; ein Transkript mit 1.000 Nachrichten kostet 10 Anfragen. Die REST-Schicht von discord.js wartet standardmäßig, wenn sie an ein Limit stößt, und sendet die Anfrage dann erneut. Das eigentliche Risiko sind ungültige Anfragen: Überschreiten Anfragen mit der Antwort 401, 403 oder 429 innerhalb von 10 Minuten die Zahl von 10.000, wird die IP-Adresse vorübergehend gesperrt; wiederholen Sie einen Vorgang, der einen Berechtigungsfehler liefert, nicht in einer Schleife. Einzelheiten stehen in der Discord-Dokumentation zu Rate Limits.

Verwandte Anleitungen

Server-Optionen, auf denen Ihr Bot dauerhaft läuft, finden Sie auf der Seite Discord Bot VDS.

Kommentare0

Noch keine Kommentare

Schreiben Sie den ersten Kommentar und teilen Sie Ihre Gedanken.

Diskutieren Sie mit

Bitte melden Sie sich an oder registrieren Sie sich, um einen Kommentar zu hinterlassen.

Keinen Beitrag verpassen

Erhalten Sie unsere neuesten Tutorials, Anleitungen und Produktneuigkeiten direkt in Ihr Postfach.

Sie haben unseren Newsletter abonniert.