Klicke auf der Seite Telegram-Bot-Hosting bei einem Tarif auf Server erstellen. Beantworte im Bestellfenster Wofür ist dein Bot? mit Telegram und wähle Java.
Baue den Bot auf deinem Computer mit der pom.xml unten: mvn package schreibt target/bot.jar, mit TelegramBots darin.
Öffne deinen Server im Panel. Die Karte Deinen Bot einrichten auf der Seite Übersicht öffnet sich bei Mit Telegram verbinden; der erste Schritt, Was läuft, sollte Dieser Bot führt Java Bot aus. anzeigen.
Füge bei Mit Telegram verbinden den Token unter Füge deinen Bot-Token ein ein, klicke auf Verbinden, prüfe den angezeigten Bot-Namen und klicke auf Ja, weiter.
Klicke bei Dein Code auf Dateien hochladen und lade bot.jar in den Hauptordner hoch.
Prüfe auf der Seite Bot im Bereich Code, dass Startdatei bot.jar ist und 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.
Klicke auf Bot starten und öffne Console. Sobald dein Bot Logged in as @your_bot ausgibt, wechselt der Chip auf Übersicht zu Online in Telegram.
Klicke auf der Seite Bot im Bereich Telegram auf In Telegram öffnen und sende deinem Bot /start.

Wie du den Bot in @BotFather anlegst und was die Panel-Schritte bedeuten, steht in So hostest du einen Telegram-Bot. Diese Seite behandelt TelegramBots selbst: was die Bibliothek auf einem Server braucht und was du vor dem Hosten wissen solltest.

Was wir gemessen haben

Bibliothek	Version	Speicher ohne Last	Start bis zu Telegrams Antwort	Jar-Größe
TelegramBots (rubenlagus)	10.3.0	91 MB	1,5 s	9,6 MB
Java 21 allein, ohne Bibliothek	21.0.12.1	38 MB	keine	0,0 MB

So haben wir gemessen: auf unserem eigenen Node, in einem Wegwerf-Container, der wie ein Bot-Tarif mit 1 GB eingerichtet war (das Java-21-Image und der genaue java-Befehl unseres Java-Bot-Typs). Der Bot rief Telegrams getMe mit einem erfundenen Token auf, den Telegram 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: noch keine Chats, keine Daten und noch kein Polling. Dein eigener Code, was er im Speicher hält, und die Zahl der Chats kommen dazu, und das Startskript lässt den Java-Heap bis auf 80 Prozent des Tarifs wachsen (siehe unten). Vergleiche die Zahlen mit den Tarifen auf Telegram-Bot-Hosting und wähle danach, was dein Bot tut.

Ein minimaler TelegramBots-Bot

Er antwortet auf /start, liest den Token aus TELEGRAM_BOT_TOKEN (das Panel gibt ihn deinem Code unter diesem Namen und außerdem als BOT_TOKEN, TOKEN, TELEGRAM_TOKEN und TELOXIDE_TOKEN) und gibt eine Bereit-Zeile aus. 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>org.telegram</groupId>
      <artifactId>telegrambots-longpolling</artifactId>
      <version>10.3.0</version>
    </dependency>
    <dependency>
      <groupId>org.telegram</groupId>
      <artifactId>telegrambots-client</artifactId>
      <version>10.3.0</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-simple</artifactId>
      <version>2.0.12</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 org.telegram.telegrambots.client.okhttp.OkHttpTelegramClient;
import org.telegram.telegrambots.longpolling.TelegramBotsLongPollingApplication;
import org.telegram.telegrambots.longpolling.util.DefaultLongPollingUpdateConsumer;
import org.telegram.telegrambots.meta.api.methods.GetMe;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.api.objects.User;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
import org.telegram.telegrambots.meta.generics.TelegramClient;

public class Bot extends DefaultLongPollingUpdateConsumer {
    private final TelegramClient client;

    Bot(TelegramClient client) {
        this.client = client;
    }

    @Override
    public void consume(Update update) {
        if (update.hasMessage() && update.getMessage().hasText()
                && update.getMessage().getText().startsWith("/start")) {
            SendMessage reply = SendMessage.builder()
                    .chatId(update.getMessage().getChatId())
                    .text("Hello! I am running on PlayNHost.")
                    .build();
            try {
                client.execute(reply);
            } catch (TelegramApiException e) {
                e.printStackTrace();
            }
        }
    }

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

        TelegramClient client = new OkHttpTelegramClient(token);
        User me = null;
        try {
            me = client.execute(new GetMe());
        } catch (TelegramApiRequestException e) {
            if (e.getErrorCode() != null && e.getErrorCode() == 401) {
                System.out.println("Telegram did not accept the bot token. Paste the current one from @BotFather on the Bot page, then restart.");
                System.exit(1);
            }
            throw e;
        }

        try (TelegramBotsLongPollingApplication app = new TelegramBotsLongPollingApplication()) {
            // Long polling: registerBot removes a webhook left on the bot, then asks Telegram for messages.
            app.registerBot(token, new Bot(client));
            System.out.println("Logged in as @" + me.getUserName());
            Thread.currentThread().join();
        }
    }
}

Baue ihn mit Maven 3.9 und einem JDK 17 oder neuer und teste die Jar auf deinem Computer:

mvn package
java -jar target/bot.jar

Ohne Token gibt sie No TELEGRAM_BOT_TOKEN found. aus und stoppt, was beweist, dass die Jar startet und ihre Main-Klasse findet. Lade target/bot.jar hoch. Beende jede Kopie, die du mit dem echten Token auf deinem Computer laufen lässt, bevor du die auf dem Server startest, sonst bekommen beide Kopien 409 Conflict-Fehler von Telegram.

Der Aufruf getMe prüft den Token, bevor das Polling beginnt, und liefert den Benutzernamen des Bots für die Bereit-Zeile. Logged in as @your_bot ist die Zeile, die den Chip auf Online in Telegram stellt.

Wenn der Token falsch ist

In unserem Test schlug TelegramBots' getMe-Aufruf mit einem erfundenen Token mit diesem Fehler fehl:

TelegramApiRequestException: Error executing org.telegram.telegrambots.meta.api.methods.GetMe query: [401] Unauthorized

Der Bot oben fängt diese Ablehnung (Fehlercode 401) ab und gibt stattdessen Telegram did not accept the bot token. Paste the current one from @BotFather on the Bot page, then restart. aus. Das Panel liest diese Zeile und zeigt über Console das Banner Telegram hat deinen Bot-Token nicht akzeptiert. Zur Behebung sendest du in @BotFather /mybots, wählst deinen Bot, dann API Token und kopierst den Token neu. Klicke auf der Seite Bot im Bereich Telegram auf Token ersetzen, füge ihn ein, klicke auf Token speichern und dann auf Jetzt neu starten.

Was du über TelegramBots auf einem Server wissen solltest

Versionen: TelegramBots 10.3.0 erschien am 7. Sep 2026 und unterstützt Telegrams Bot API 10.3. Es braucht Java 17 oder neuer, also läuft es mit jeder Laufzeitumgebung, die das Panel anbietet (Java 17, 21 oder 25).
Zwei Pakete, anders als in älteren Tutorials. Seit Version 7.0.0 (März 2024) besteht die Bibliothek aus telegrambots-longpolling, das Nachrichten empfängt, und telegrambots-client, das sie sendet. Tutorials, die TelegramLongPollingBot erweitern, wurden für das alte Paket telegrambots geschrieben, zuletzt als 6.9.7.1 veröffentlicht; diese Klasse gibt es in 10.3.0 nicht, ihr Code lässt sich damit also nicht kompilieren.
Nutze Long Polling. Die Bibliothek hat auch ein Webhook-Modul, aber ein Webhook braucht eine öffentliche HTTPS-Adresse, die unsere Tarife noch nicht enthalten. registerBot im Long-Polling-Modul ruft deleteWebhook auf, bevor es startet, ein von einem alten Host übrig gebliebener Webhook wird also entfernt und die wartenden Nachrichten bleiben erhalten. Umzug von einem Webhook-Host: So ziehst du einen Telegram-Bot zu PlayNHost um.
Füge eine Logging-Bibliothek hinzu, sonst schweigt die Bibliothek. TelegramBots loggt über SLF4J. Ohne SLF4J-Provider in deiner Jar gibt SLF4J einmal eine Warnung aus und verwirft dann jede Log-Zeile der Bibliothek, auch die Fehler vom Polling. Die pom.xml oben fügt slf4j-simple hinzu, das die Zeilen der Bibliothek ab INFO auf die Standardfehlerausgabe schreibt, sodass sie in der Console erscheinen.
Polling-Fehler werden wiederholt, nicht geworfen. Wenn ein getUpdates-Aufruf fehlschlägt, loggt TelegramBots Error received from Telegram GetUpdates Request, retrying in ... millis und versucht es erneut, der Prozess läuft also weiter. Die Wartezeit beginnt bei etwa einer halben Sekunde und wächst jedes Mal um die Hälfte bis auf etwa eine Minute (mit zufälliger Streuung bis zu 90 Sekunden); sobald 15 Minuten ohne erfolgreichen Aufruf vergangen sind, wartet es 15 Minuten zwischen den Versuchen. Starte den Bot daher nach der Behebung der Ursache neu, statt zu warten. Nur der HTTP-Statuscode in der Zeile Caused by des Stacktraces darunter sagt, was schiefging; Telegrams eigene Fehlerbeschreibung wird nicht ausgegeben. Da registerBot einen Webhook schon entfernt hat, bedeutet ein 409 dort meist, dass eine andere Kopie des Bots mit demselben Token pollt: Stoppe sie. Siehe Telegram-Bot-Fehler 409 Conflict beheben.
Die offizielle Anleitung, aktualisiert: Sie implementiert LongPollingSingleThreadUpdateConsumer, das 10.3.0 zugunsten der oben verwendeten Klasse DefaultLongPollingUpdateConsumer als veraltet markiert; beide verarbeiten Updates nacheinander in einem Hintergrund-Thread. Ihre Bereit-Zeile MyAmazingBot successfully started! stellt den Chip nicht auf Online in Telegram: Gib eine Zeile aus, die mit Logged in as beginnt, wie oben.
Lass main() warten. Das Polling läuft auf den eigenen Threads der Bibliothek; die Anleitung beendet main() mit Thread.currentThread().join(), damit das Programm nicht endet, und der Bot oben macht dasselbe.
Speicherlimit: Das Startskript startet Java mit -XX:MaxRAMPercentage=80.0 und dem G1-Garbage-Collector, der Heap kann also bis zu 80 Prozent des Tarifspeichers nutzen. Wenn er voll ist, gibt Java java.lang.OutOfMemoryError aus und das Panel zeigt Deinem Bot ist der Arbeitsspeicher ausgegangen.
Eine Jar, nichts auf dem Server installiert. Der Java-Bot-Typ startet java -jar mit deiner Startdatei und hat kein Feld Pakete, also muss alles in der Jar stecken. Lade eine neue Jar hoch, um den Bot zu aktualisieren.

Selbst auf einem Linux-VPS hosten

Ein VPS braucht nur eine Java-Laufzeit, denn die Jar baust du auf deinem eigenen Computer. Installiere unter Debian 13 oder Ubuntu 24.04 Java 21; Debian 12 liefert Java 17, das die 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 die 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 "TELEGRAM_BOT_TOKEN=123456789:your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env

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

[Unit]
Description=TelegramBots Telegram 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 ihn 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 gesamten Speicher der Maschine, senke ihn also, wenn dort noch andere Programme laufen. Zum Aktualisieren kopierst du die neue Jar über die alte und führst sudo systemctl restart mybot aus.

Selbst hosten oder Bot-Tarif

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

Betriebssystem-Updates und Sicherheit sowie Java-Upgrades.
Das Kopieren jeder neuen Jar, die Service-Datei, die Token-Datei und ihre Berechtigungen.
Das Lesen von journalctl, um herauszufinden, warum der Bot gestoppt hat oder nicht mehr antwortet.
Backups von allem, was dein Bot speichert.

Dafür läuft auf einem VPS alles, und du kannst ihm eine Domain mit HTTPS für einen Webhook geben.

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

Java 17, 21 oder 25 per Auswahl, mit gesetztem Heap-Limit und Garbage-Collector.
Der Token wird mit Telegram geprüft, bevor er gespeichert wird, verschlüsselt abgelegt und deinem Code unter fünf Namen übergeben.
Neustart des Bots nach einem Absturz. Stürzt er innerhalb einer Minute erneut ab, bleibt er gestoppt und die Console nennt den Grund.
Eine Schaltfläche Webhook entfernen im Bereich Telegram und Banner über der Console, die die Ursache nennen, etwa einen abgelehnten Token oder zu wenig Speicher.
Upload im Browser und Backups aus dem Panel.

Häufige Fragen

Mein TelegramBots-Bot läuft, antwortet aber nicht und gibt nichts aus. Warum?

Meist hat die Jar keinen SLF4J-Provider, sodass die eigenen Fehlerzeilen der Bibliothek verworfen werden, während sie weiter wiederholt. Füge slf4j-simple wie in der pom.xml oben hinzu, baue neu und sieh in die Console. Ein wiederholtes 409 heißt, dass eine andere Kopie des Bots mit demselben Token pollt; ein wiederholtes 401 heißt, dass der Token in @BotFather widerrufen wurde. Starte den Bot nach der Behebung neu: Die Wartezeit von TelegramBots zwischen den Versuchen kann 15 Minuten erreichen.

Kann ich das Webhook-Modul von TelegramBots nutzen?

Auf unseren Tarifen noch nicht: Ein Webhook braucht eine öffentliche HTTPS-Adresse, die sie nicht enthalten. Long Polling braucht keine, weil der Bot Telegram nach neuen Nachrichten fragt. Nutze telegrambots-longpolling wie auf dieser Seite.

Braucht TelegramBots einen größeren Tarif als ein Python- oder Node.js-Bot?

Nicht wegen der Bibliothek selbst. Im selben Test, auf dieselbe Weise ausgeführt, brauchte TelegramBots 91 MB, python-telegram-bot 22.8 brauchte 44 MB, grammY 1.46.0 brauchte 60 MB und aiogram 3.31.0 brauchte 173 MB, alle weit unter den 0,5 GB des kleinsten Tarifs. Was dein Bot im Speicher hält, entscheidet den Rest. Bei Java hängt der Speicher außerdem vom Heap ab: Das Startskript lässt ihn bis auf 80 Prozent des Tarifs wachsen, und der Garbage-Collector entscheidet, wie viel davon genutzt wird.

Welche Java-Version soll ich wählen?

Java 21, die empfohlene, es sei denn, dein eigener Code braucht 25. TelegramBots 10.3.0 braucht Java 17 oder neuer. Baue mit einem release, das nicht neuer ist als die gewählte Laufzeitumgebung: Eine für ein neueres Java gebaute Jar stoppt mit UnsupportedClassVersionError.

Bereit, deinen TelegramBots-Bot rund um die Uhr laufen zu lassen? Sieh dir die Tarife auf Telegram-Bot-Hosting an.

TelegramBots-Bot (Java) 24/7 hosten

Was wir gemessen haben

Ein minimaler TelegramBots-Bot

Wenn der Token falsch ist

Was du über TelegramBots auf einem Server wissen solltest

Selbst auf einem Linux-VPS hosten

Selbst hosten oder Bot-Tarif

Häufige Fragen

Mein TelegramBots-Bot läuft, antwortet aber nicht und gibt nichts aus. Warum?

Kann ich das Webhook-Modul von TelegramBots nutzen?

Braucht TelegramBots einen größeren Tarif als ein Python- oder Node.js-Bot?

Welche Java-Version soll ich wählen?

UNSERE NEUESTEN BLOGS

Beste Factorio-Mods für Mehrspieler-Server im Jahr 2026

Terraria-Server-Optimierung: Einstellungen, Specs und Server-Tipps

Counter-Strike 2 Performance und Systemanforderungen: Ping und FPS verbessern

Wir verwenden Cookies