NEU 📢 Black Friday: Unser Startangebot endet am 30. Nov. Bis zu 70 % Rabatt auf deinen ersten Monat, für jedes Spiel!Tarife ansehen
Black FridayBis zu 70 % Rabatt auf deinen ersten Monat, endet am 30. Nov.Endet in 9 T. 02 Std. 49 Min.Black FridayBis zu 70 % Rabatt auf deinen ersten Monat, endet am 30. Nov.Endet in 9 T. 02 Std. 49 Min.Black FridayBis zu 70 % Rabatt auf deinen ersten Monat, endet am 30. Nov.Endet in 9 T. 02 Std. 49 Min.

Discord4J-Bot 24/7 hosten

Discord-Bot-HostingAktualisiert 6. Nov. 202613 Min. Lesezeit

Um einen Discord4J-Bot 24/7 zu hosten, lässt du ihn auf einer Maschine laufen, die immer an ist: auf einem Linux-VPS mit einem systemd-Dienst, der ihn neu startet, wenn er stoppt, oder in einem Bot-Plan bei PlayNHost Discord-Bot-Hosting (ab 1,99 US$ im Monat), wo du ein lauffähiges Jar hochlädst, den Token einfügst und auf Start klickst. In unserem Test brauchte ein Discord4J-3.3.3-Bot unter Java 21 etwa 126 MB Speicher und bekam 2,6 Sekunden nach dem Start Discords Antwort. Discord4J ist eine Bibliothek und kein Programm, also baust du deinen Bot zuerst auf deinem eigenen Rechner zu einem Jar. Die Schritte bei PlayNHost:

  1. Klicke auf der Seite Discord-Bot-Hosting bei einem Plan auf Server erstellen. Beantworte im Bestellfenster Wofür ist dein Bot? mit Discord und wähle Java.
  2. Baue den Bot auf deinem Rechner mit der pom.xml weiter unten: mvn package schreibt target/bot.jar, Discord4J steckt schon drin.
  3. Öffne deinen Server im Panel. Die Karte Deinen Bot einrichten auf der Übersicht öffnet sich bei Mit Discord verbinden. Der erste Schritt, Was läuft, sollte Dieser Bot führt Java Bot aus. anzeigen; klicke auf diesen Schritt, um das zu prüfen, dann auf Weiter.
  4. Füge bei Mit Discord verbinden deinen Token in Füge deinen Bot-Token ein ein, klicke auf Verbinden und dann auf Ja, weiter.
  5. Setze bei Berechtigungen nur für die privilegierten Intents, die dein Code anfordert, den Haken bei Mein Code nutzt das (der Bot unten braucht keinen), klicke auf Zu einem Discord-Server hinzufügen und dann auf Weiter.
  6. Klicke bei Dein Code auf Dateien hochladen und lade bot.jar in den Hauptordner hoch.
  7. Prüfe auf der Seite Bot im Bereich Code, dass die Startdatei bot.jar ist und die Laufzeitumgebung Java 21 (recommended), oder Java 17 oder 25. Wenn du die Startdatei änderst, klicke daneben auf Speichern; eine neue Laufzeitumgebung wird gespeichert, sobald du sie auswählst.
  8. Klicke auf Bot starten und beobachte die Console. Sobald dein Bot Logged in as ... ausgibt, steht in der Karte Dein Bot ist online in Discord.

Wie du den Bot und seinen Token erstellst, steht in So erstellst du einen Discord-Bot und holst seinen Token, den Java-Bot-Typ allgemein erklärt So hostest du einen Java-Discord-Bot. Diese Seite handelt von Discord4J selbst: was es auf einem Server braucht und was du vor dem Hosten wissen solltest.

Was wir gemessen haben

BibliothekVersionArbeitsspeicher nach dem StartStart bis Discords AntwortJar-Größe
Discord4J3.3.3126 MB2,6 s37 MB
JDA6.7.091 MB1,5 s19 MB
Java 21 allein, ohne Bibliothek21.0.12.138 MBkeine0,0 MB

So haben wir gemessen: auf unserem eigenen Node, in einem Wegwerf-Container, der wie ein Bot-Plan mit 1 GB eingerichtet war (das Java-21-Image und der genaue java-Befehl unseres Java-Bot-Typs). Jeder Bot meldete sich mit einem falschen Token an, den Discord ablehnte. Der Speicher ist der belegte Speicher 15 Sekunden nach dieser Antwort, die Startzeit läuft vom Start bis zur Antwort, und jeder Wert ist der Median der Läufe 2 bis 4.

Das sind Untergrenzen: keine Server, keine zwischengespeicherten Mitglieder, noch keine offene Gateway-Sitzung. Dein eigener Code und die Zahl der Server, in denen dein Bot ist, kommen dazu, und das Startskript lässt den Java-Heap auf bis zu 80 Prozent des Plans wachsen (siehe unten). Vergleiche die Zahlen mit den Plänen unter Discord-Bot-Hosting und wähle danach, was dein Bot tut.

Ein minimaler Discord4J-Bot

Er registriert einen Slash-Befehl /ping, antwortet darauf mit Pong!, liest den Token aus DISCORD_TOKEN (so nennt das Panel ihn) und gibt eine Bereit-Zeile aus. Er braucht keinen privilegierten Intent. Zwei Dateien:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>bot</artifactId>
  <version>1.0</version>
  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>com.discord4j</groupId>
      <artifactId>discord4j-core</artifactId>
      <version>3.3.3</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>bot</finalName>
    <plugins>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.7.1</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <appendAssemblyId>false</appendAssemblyId>
          <archive>
            <manifest>
              <mainClass>Bot</mainClass>
            </manifest>
          </archive>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

src/main/java/Bot.java

import discord4j.core.DiscordClient;
import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
import discord4j.core.event.domain.lifecycle.ReadyEvent;
import discord4j.discordjson.json.ApplicationCommandRequest;
import discord4j.rest.http.client.ClientException;
import reactor.core.publisher.Mono;

public class Bot {
    public static void main(String[] args) {
        String token = System.getenv("DISCORD_TOKEN");
        if (token == null || token.isBlank()) {
            System.out.println("No DISCORD_TOKEN found. Paste your bot token on the Bot page, then restart.");
            System.exit(1);
        }

        ApplicationCommandRequest ping = ApplicationCommandRequest.builder()
                .name("ping")
                .description("Replies with Pong!")
                .build();

        try {
            DiscordClient.create(token).withGateway(gateway -> {
                // Creating a command that already exists updates it, so this is safe on every start.
                Mono<Void> register = gateway.getRestClient().getApplicationId()
                        .flatMap(appId -> gateway.getRestClient().getApplicationService()
                                .createGlobalApplicationCommand(appId, ping))
                        .then();

                Mono<Void> ready = gateway.on(ReadyEvent.class, event -> Mono.fromRunnable(() ->
                        System.out.println("Logged in as " + event.getSelf().getUsername())))
                        .then();

                Mono<Void> commands = gateway.on(ChatInputInteractionEvent.class, event -> {
                    if (event.getCommandName().equals("ping")) {
                        return event.reply("Pong!");
                    }
                    return Mono.empty();
                }).then();

                return register.and(ready).and(commands);
            }).block();
        } catch (RuntimeException e) {
            if (ClientException.isStatusCode(401).test(e)) {
                System.out.println("Discord did not accept the bot token. Copy it again (Developer Portal, Bot, Reset Token), paste it on the Bot page, then restart.");
            } else {
                e.printStackTrace();
            }
            System.exit(1);
        }
    }
}

Baue ihn mit Maven 3.9 und einem JDK 17 oder neuer:

mvn package
java -jar target/bot.jar

Die zweite Zeile ist ein Test auf deinem Rechner: Ohne Token gibt sie No DISCORD_TOKEN found. aus und endet, was beweist, dass das Jar startet und seine Hauptklasse findet. Lade target/bot.jar hoch. Das jar-with-dependencies des maven-assembly-plugin packt Discord4J und alles, was es braucht, in dieses eine Jar; mit Gradle erreichst du dasselbe über das Shadow-Plugin. Mit maven.compiler.release 17 entsteht ein Jar, das auf allen drei Java-Versionen läuft, die das Panel anbietet.

Die Zeile Logged in as ... schaltet den Chip auf der Übersicht auf Online in Discord. Lade den Bot mit Zu einem Discord-Server hinzufügen ein, bevor du /ping ausprobierst: So lädst du deinen Discord-Bot auf einen Server ein.

Wenn der Token falsch ist

In unserem Test schlug der Login von Discord4J mit einem falschen Token mit diesem Fehler fehl:

ClientException: GET /gateway/bot returned 401 Unauthorized with response {code=0, message=401: Unauthorized}

Der Bot oben fängt einen abgelehnten Token (HTTP 401) ab und gibt statt eines Stacktraces Discord did not accept the bot token. Copy it again (Developer Portal, Bot, Reset Token), paste it on the Bot page, then restart. aus, dann endet er mit Exit-Code 1. Als wir ihn mit einem falschen Token starteten, kamen zuerst drei Warnzeilen mit SLF4J:, die erste beginnt mit SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".; sie betreffen das Logging, nicht den Token (siehe Logs unten). Zur Behebung öffnest du das Discord Developer Portal, deine Anwendung, Bot, und klickst auf Reset Token; Discord zeigt den neuen Token nur einmal. Klicke auf unserer Seite Bot im Bereich Discord auf Token ersetzen, füge ihn ein, klicke auf Token speichern und dann auf Jetzt neu starten. Wenn Discord die Prüfung des gespeicherten Tokens ablehnt, zeigt der Bereich Discord hat ihn nicht akzeptiert.

Was du über Discord4J auf einem Server wissen solltest

  • Versionen: Discord4J 3.3.3 erschien am 19. August 2026. Die Reihe 3.3 ist die aktuelle, 3.2 wird nur noch gewartet. Discord4J 3.3.3 ist für Java 8 kompiliert, daher läuft es auf jeder Laufzeitumgebung, die das Panel anbietet (Java 17, 21 oder 25); baue mit einem release, das nicht neuer ist als die gewählte Laufzeitumgebung.
  • Ein Jar, nichts auf dem Server installiert. Der Java-Bot-Typ hat keine Git-Quelle und kein Feld Pakete: Er startet java -jar auf deiner Startdatei, also muss alles, was dein Bot braucht, im Jar stecken. Lade zum Aktualisieren des Bots ein neues Jar hoch.
  • Speicherlimit: Das Startskript startet Java mit -XX:MaxRAMPercentage=80.0 und dem G1-Garbage-Collector, sodass der Heap bis zu 80 Prozent des Plan-Speichers nutzen kann und der Rest des Prozesses Platz hat. Läuft der Heap voll, gibt Java java.lang.OutOfMemoryError aus und das Panel zeigt Deinem Bot ist der Arbeitsspeicher ausgegangen.
  • Intents: Discord4J verbindet sich mit allen nicht privilegierten Intents, solange du keine anderen wählst. Das Beispiel !ping aus der README von Discord4J liest Nachrichtentext, wofür der privilegierte Intent Message Content nötig ist: Schalte ihn im Developer Portal ein, fordere ihn im Code mit DiscordClient.create(token).gateway().setEnabledIntents(IntentSet.nonPrivileged().or(IntentSet.of(Intent.MESSAGE_CONTENT))) an und setze bei unserem Schritt Berechtigungen den Haken bei Mein Code nutzt das. Ohne ihn schickt Discord dem Bot leeren Nachrichtentext, außer in Direktnachrichten und bei Nachrichten, die den Bot erwähnen. Ein Slash-Befehl wie oben braucht nichts davon. Siehe „Used disallowed intents“ bei deinem Discord-Bot beheben.
  • Logs: Discord4J loggt über Reactor, das SLF4J nutzt, wenn SLF4J im Jar ist, und Discord4J bringt SLF4J mit. Ohne Logging-Bibliothek dahinter, wie in der pom.xml oben, gibt SLF4J beim Start drei Warnzeilen aus, die letzte SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details., und wirft danach die eigenen Logzeilen von Discord4J weg, auch Fehler. Deine System.out-Zeilen erscheinen weiterhin in der Console. Um die Zeilen von Discord4J zu sehen, füge eine Logging-Bibliothek hinzu; die Doku von Discord4J empfiehlt Logback.
  • Lass main() warten. Discord4J ist reaktiv: Sein Login ist ein Mono, der sich verbindet, sobald ihn jemand abonniert. Die Beispiele in der README enden mit main() bei gateway.onDisconnect().block() oder mit block() auf withGateway(...), was wartet, solange der Bot verbunden ist. Der Bot oben nutzt withGateway(...).block().
  • Befehle bei jedem Start zu registrieren ist in Ordnung. Discord behandelt das Anlegen eines Befehls mit einem Namen, den deine Anwendung schon nutzt, als Aktualisierung dieses Befehls, daher häuft der Bot oben keine Kopien von /ping an.
  • Abstürze: Wenn der Bot sich beendet, wie der Bot oben bei einem abgelehnten Token, startet das Panel ihn sofort neu. Stoppt er danach innerhalb einer Minute erneut, bleibt er gestoppt und die Console nennt den Grund.

Auf einem eigenen Linux-VPS hosten

Ein VPS braucht nur eine Java-Laufzeit, denn das Jar baust du auf deinem eigenen Rechner. Installiere auf Debian 13 oder Ubuntu 24.04 Java 21; Debian 12 liefert Java 17, das das Jar oben ebenfalls ausführt:

sudo apt update
sudo apt install openjdk-21-jre-headless
java -version

Lege einen Benutzer für den Bot an und kopiere das Jar auf den Server (zum Beispiel mit scp), dann in seinen Ordner:

sudo useradd --system --create-home --home-dir /opt/mybot mybot
sudo cp bot.jar /opt/mybot/
sudo chown -R mybot: /opt/mybot

Halte den Token aus deinem Code heraus, in einer Datei, die nur root lesen kann:

sudo sh -c 'echo "DISCORD_TOKEN=your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env

Erstelle /etc/systemd/system/mybot.service:

[Unit]
Description=Discord4J bot
Wants=network-online.target
After=network-online.target

[Service]
User=mybot
WorkingDirectory=/opt/mybot
EnvironmentFile=/etc/mybot.env
ExecStart=/usr/bin/java -XX:MaxRAMPercentage=80.0 -jar /opt/mybot/bot.jar
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Starte den Dienst jetzt und bei jedem Boot und verfolge dann seine Ausgabe:

sudo systemctl daemon-reload
sudo systemctl enable --now mybot
sudo journalctl -u mybot -f

Restart=always startet den Bot 5 Sekunden nach einem Ende oder Absturz neu, aber nicht, wenn du ihn mit systemctl stop stoppst. Auf einem VPS ist -XX:MaxRAMPercentage ein Anteil am Speicher der ganzen Maschine, senke ihn also, wenn dort noch andere Programme laufen. Zum Aktualisieren kopierst du das neue Jar über das alte und führst sudo systemctl restart mybot aus.

Selbst hosten oder Bot-Plan

Auf einem VPS, den du selbst verwaltest, kümmerst du dich um:

  • Updates und Sicherheit des Betriebssystems sowie Java-Upgrades.
  • Das Kopieren jedes neuen Jars, die Service-Datei, die Token-Datei und ihre Rechte.
  • Das Lesen von journalctl, um herauszufinden, warum der Bot gestoppt hat.
  • Backups von allem, was dein Bot speichert.

Dafür führt ein VPS alles aus, was du darauf installierst.

In einem PlayNHost-Bot-Plan übernimmt das Panel das für dich:

  • Java 17, 21 oder 25 aus einer Auswahl, mit gesetztem Heap-Limit und Garbage-Collector.
  • Der Token, vor dem Speichern bei Discord geprüft, verschlüsselt abgelegt und als DISCORD_TOKEN an deinen Code übergeben.
  • Ein Einladungslink mit den Berechtigungen, die du wählst, und eine Karte Privilegierte Intents, die prüft, welche in deinem Developer Portal eingeschaltet sind.
  • Der Neustart des Bots nach einem Absturz und ein Banner über der Console, wenn ihm der Speicher ausgeht.
  • Upload aus dem Browser und Backups aus dem Panel.

Häufige Fragen

Mein Discord4J-Bot ist online, aber !ping bewirkt nichts. Warum?

Weil der Nachrichtentext leer ist. Discord4J fordert standardmäßig nur nicht privilegierte Intents an, und für das Lesen von Nachrichtentext auf Servern braucht es Message Content, einen privilegierten Intent. Schalte ihn im Developer Portal ein und fordere ihn wie oben gezeigt mit setEnabledIntents an, oder nutze einen Slash-Befehl wie /ping im Bot auf dieser Seite, der keinen privilegierten Intent braucht.

Discord4J oder JDA bei PlayNHost?

Beide laufen auf demselben Java-Bot-Typ, aus derselben Art Jar. Die Tabelle oben zeigt den Speicher, den wir für jeden gemessen haben. Der eigentliche Unterschied ist der Stil: Discord4J baut auf Reactor, du verkettest also Mono und Flux, während JDA Listener und Callbacks nutzt. Nimm die Bibliothek, deren Code du leichter liest. Die Schritte für JDA: So hostest du einen Java-Discord-Bot.

Welche Java-Version soll ich für Discord4J wählen?

Java 21, die empfohlene, es sei denn, dein eigener Code braucht 25. Discord4J selbst läuft ab Java 8, die Grenze ist also das release, mit dem du baust: Ein Jar, das für ein neueres Java gebaut wurde, als der Server nutzt, endet mit UnsupportedClassVersionError. Wähle eine neuere Laufzeitumgebung oder baue mit einem niedrigeren release.

Warum ist mein Discord4J-Jar so groß?

Weil es alles enthält: Discord4J bringt Reactor, Netty, Jackson und eigene Voice-Module mit, und der Build mit jar-with-dependencies packt sie alle ein. Das Jar in unserem Test war 37 MB groß. Das ist Speicherplatz in deinem Plan; den Arbeitsspeicher des laufenden Bots zeigt die Tabelle oben.

Bereit, deinen Discord4J-Bot rund um die Uhr laufen zu lassen? Die Pläne findest du unter Discord-Bot-Hosting.

Läuft dein Bot schon woanders? Zieh ihn zu uns um

UNSERE NEUESTEN BLOGS