Table of Contents

Telegram ist mehr als nur eine Messaging-App. Es hat sich zu einer vielseitigen Plattform für die Automatisierung und die Entwicklung interaktiver Dienste entwickelt. Besonders im Bereich der KI-Anwendungen und Tools wie n8n wird Telegram immer beliebter, da es eine direkte bidirektionale Kommunikation mit Menschen ermöglicht. Für Entwickler, die diese Möglichkeiten nutzen möchten, gibt es zwei fundamentale Ansätze: die Bot API und die MTProto-API.

Die Bot API: Der Standardweg für die meisten Bots

Die Bot API stellt die unkomplizierteste und am häufigsten genutzte Methode zur Erstellung eines Telegram-Bots dar. Sie wurde speziell für die einfache Entwicklung automatisierter Dienste konzipiert.

Vorteile

Einfachheit: Verwendet das Standard-HTTPS-Protokoll.
Sicherheit: Die Kommunikation mit den Telegram-Servern wird automatisch verwaltet, die Entwicklung erfolgt über einen einfachen API-Token.
Automatisierung: Ideal für automatisierte Reaktionen auf bestimmte Ereignisse oder Befehle.

Nachteile

Eingeschränkte Funktionalität: Unterliegt strengen Datenschutzregeln. Der Abruf privater Daten wie dem Online-Status eines Nutzers ist nicht möglich.
Begrenzte Interaktion: Kann die Benutzeroberfläche eines menschlichen Clients nicht vollständig nachahmen.

Die MTProto-API: Der Weg für fortgeschrittene Anwendungen

Die MTProto-API ist das grundlegende Protokoll, das auch von den offiziellen Telegram-Apps verwendet wird. Es ist komplexer, bietet dafür aber einen deutlich breiteren Funktionsumfang.

Vorteile

Volle Kontrolle: Ermöglicht den Zugriff auf sämtliche Telegram-Funktionen, einschließlich der Verwaltung von Kontakten, dem Abruf von Online-Status und dem Auslesen von Mitgliederlisten in Gruppen und Kanälen.
Flexibilität: Die Entwicklung einer Anwendung, die nicht als „Bot“, sondern als normaler Telegram-Nutzer agiert, ist möglich.

Nachteile

Komplexität: Das Protokoll ist aufgrund seiner eigenen Verschlüsselungs- und Sitzungsverwaltung anspruchsvoll in der Implementierung.
Verantwortung: Der Entwickler ist selbst für die Einhaltung von Datenschutzrichtlinien verantwortlich, da der Zugriff auf private Nutzerdaten möglich ist.

Wahl der richtigen API

Für die meisten Projekte, insbesondere für Einsteiger, wird die Bot API empfohlen. Sie ist einfach zu erlernen und erfüllt die Anforderungen der meisten Bot-Anwendungen. Die MTProto-API wird erst relevant, wenn eine Anwendung spezifische Funktionen benötigt, die die Bot API nicht bietet, wie die Überwachung der Online-Präsenz von Nutzern oder das Extrahieren von vollständigen Mitgliederlisten.

Wir konzentrieren uns zunächst auf die einfache Möglichkeit und schauen uns an, wie ein grundlegender Bot erstellt wird. Dieser Tutorial behandelt im weiteren Verlauf die Implementierung via Bot API mit Hilfe von BotFather.

Bot API & BotFather

Um mit der Bot API einen eigenen Telegram Bot zu erstellen führt der Weg über den offiziellen BotFather. Dieser Bot ist direkt von Telegram bereitgestellt und dient als zentrale Anlaufstelle für die Registrierung neuer Bots. Er ist leicht in der Suche von Telegram zu finden und an dem blauen Haken erkennbar, der bestätigt, dass es sich um das Original handelt.

Sobald man den Bot öffnet, wird ein Menü angezeigt, das weitere Einstellungen und Optionen ermöglicht. Auf diese Weise beginnt praktisch jedes Projekt mit der Bot API, da hier die grundlegenden Informationen vergeben werden, die für die spätere Nutzung notwendig sind.

Bot Name
Das ist der Anzeigename, den Nutzer in Telegram sehen, wenn sie mit dem Bot interagieren. Er kann Leerzeichen enthalten und muss nicht einzigartig sein. Mehrere Bots können also denselben Namen haben. Beispiel: Ein Bot kann den Namen „NetPerformance“ haben, auch wenn es andere Bots gibt, die genauso heißen.

Username
Der Username ist die eindeutige Adresse des Bots in Telegram und endet immer auf „bot“. Er darf keine Leerzeichen enthalten. Nur mit diesem Namen kann der Bot eindeutig gefunden und aufgerufen werden, zum Beispiel über den Link t.me/NetPerformance_bot. Der Username muss einzigartig sein, das heißt, er darf weltweit nur einmal vergeben sein.

Mit dem Befehl /mybots zeigt BotFather alle Bots an, die du bereits erstellt hast. In der Liste erscheinen die Usernames deiner Bots, also die eindeutigen Adressen, die immer auf „bot“ enden. Auf dem Screenshot ist zu sehen, dass der Bot mit dem Username NetPerformance_bot erfolgreich angelegt wurde. So kannst du jederzeit eine Übersicht deiner eigenen Bots abrufen.

Wenn du in BotFather einen deiner Bots auswählst, öffnet sich ein Menü mit verschiedenen Optionen. Jede dieser Optionen dient dazu, den Bot zu verwalten oder seine Eigenschaften zu ändern.

API Token
Hier erhältst du den eindeutigen Zugriffsschlüssel für deinen Bot. Dieser Token ist notwendig, um über die Telegram Bot API mit deinem Bot zu kommunizieren. Mit ihm kannst du Anfragen an die API senden, Nachrichten abrufen oder Antworten verschicken. Der Token ist vergleichbar mit einem Passwort und sollte sicher aufbewahrt werden, da jeder, der ihn kennt, deinen Bot kontrollieren kann.

Edit Bot
Über diese Funktion kannst du grundlegende Angaben zum Bot ändern, zum Beispiel den sichtbaren Namen oder das Profilbild.

Bot Settings
In diesem Bereich kannst du weitere Einstellungen vornehmen, etwa die Beschreibung, den About-Text oder die Liste der Befehle, die der Bot Nutzern anbietet.

Payments
Hier lassen sich Zahlungsfunktionen aktivieren, mit denen der Bot beispielsweise Bestellungen oder Käufe abwickeln kann.

Transfer Ownership
Diese Option erlaubt es dir, den Bot an einen anderen Telegram-Account zu übertragen.

Delete Bot
Mit dieser Funktion kannst du den Bot dauerhaft löschen. Danach ist er nicht mehr über Telegram erreichbar.

Über dieses Menü steuerst du also alle zentralen Funktionen rund um deinen Bot, wobei das API Token die wichtigste Grundlage ist, um überhaupt mit der Bot API zu arbeiten.

Anzeige der Token-API.

Dieser Bildschirm zeigt den Bot im normalen Telegram-Chatfenster, so wie ihn ein Nutzer sieht, wenn er ihn zum ersten Mal öffnet.

Die Schaltfläche Starten ist notwendig, weil ein Bot erst nach einem aktiven Startbefehl mit einem Nutzer interagieren darf. Damit wird eine sogenannte Session eröffnet. Telegram verlangt diesen Schritt, um sicherzustellen, dass der Kontakt bewusst vom Nutzer ausgeht und nicht ungefragt Nachrichten verschickt werden.

Ohne diesen Startvorgang würde der Bot nicht wissen, dass er mit dir kommunizieren darf.

Auf diesem Bildschirm ist zu sehen, dass ich als Nutzer nach dem Startbefehl eine erste eigene Nachricht mit dem Text „Hello Bot!“ an den Bot gesendet habe.

Um zu prüfen, ob mein Bot Nachrichten empfängt, habe ich die Methode getUpdates der Telegram Bot API via Postman aufgerufen. Dafür nutze ich die URL https://api.telegram.org/bot<API Token>/getUpdates. Die API liefert mir im JSON-Format die letzten Ereignisse zurück, die bei meinem Bot eingegangen sind.

Im Beispiel ist zu sehen, dass meine zuvor gesendete Nachricht /start erfolgreich im Ergebnis erscheint. Neben dem Text werden auch weitere Informationen übermittelt, zum Beispiel die eindeutige chat.id, mein Benutzername und die Spracheinstellung. Diese Daten sind wichtig, weil sie später genutzt werden, um gezielt Antworten an den richtigen Chat zu schicken.

Damit ist der erste Schritt getan: Mein Bot empfängt Nachrichten, und ich kann über die Bot API nachvollziehen, welche Eingaben bei ihm ankommen.

Nachdem ich mit getUpdates die eingehenden Nachrichten abgerufen habe, sende ich nun selbst eine Nachricht zurück. Dafür nutze ich die Methode sendMessage der Telegram Bot API.

Der Bot hat damit zum ersten Mal von sich aus eine Kommunikation mit einem Benutzer aufgenommen und eine Antwort gesendet. Damit ist die erste vollständige Kommunikation hergestellt.

Bis hierhin haben wir gesehen, dass ein Bot Nachrichten empfangen und auch wieder an einen Benutzer zurückschicken kann. Damit ist der grundlegende Kommunikationsfluss hergestellt. Was jedoch noch fehlt, ist die eigentliche Logik im Hintergrund, die den Bot erst nützlich macht.

In einem echten Anwendungsfall reicht es nicht, dass der Bot lediglich Nachrichten entgegennimmt und einfache Antworten zurückschickt. Stattdessen braucht es ein eigenes Backend, das die eingehenden Nachrichten verarbeitet. Dieses Backend kann zum Beispiel prüfen, welche Inhalte der Nutzer gesendet hat, bestimmte Regeln anwenden oder Daten aus einer externen Quelle abrufen. Auf dieser Grundlage wird dann die passende Antwort erstellt.

Der Ablauf sieht also so aus: Der Benutzer schreibt dem Bot eine Nachricht. Diese Nachricht wird an die Bot API weitergeleitet, die sie an das Backend weitergibt. Dort läuft die eigentliche Logik, die entscheidet, welche Antwort zurückgesendet wird. Erst dann übermittelt die Bot API diese Antwort wieder an den Benutzer.

Mit diesem Zwischenschritt entsteht ein vollständig automatisierter Prozess. Der Bot wird dadurch mehr als nur ein Echo, er wird zu einem Werkzeug, das Informationen bereitstellt, Eingaben verarbeitet und komplexe Aufgaben übernimmt.

Bot API und OpenWeatherMap

Nachdem mein Bot einfache Nachrichten empfangen und wieder zurückschicken konnte, möchte ich ihn jetzt um eine echte Funktion erweitern. Dazu soll er auf den Befehl /wetter reagieren und aktuelle Wetterdaten aus Düsseldorf liefern.

Wichtig ist dabei zu verstehen, dass der Bot selbst eigentlich keine eigene Logik hat. Er ist eher wie ein Postfach, in das Nutzer ihre Nachrichten legen. Über die Bot API kann ich diese Nachrichten abholen. Erst mein eigenes Backend entscheidet, ob und wie auf eine bestimmte Eingabe reagiert wird. Schreibe ich also „Banane“ oder „Kiwi“, passiert nichts, außer dass die Nachricht angezeigt wird. Schreibe ich „/wetter“, erkennt mein Backend diesen speziellen Text und führt dann die gewünschte Aktion aus.

Damit das funktioniert, muss mein Backend die eingehenden Nachrichten von Telegram entgegennehmen. Dafür stellt die Bot API zwei verschiedene Möglichkeiten bereit:

Long Polling
Mit der Methode getUpdates fragt mein Backend die Bot API nach neuen Nachrichten ab. Dabei kann ich einen Timeout-Wert setzen, zum Beispiel 30 Sekunden. Während dieser Zeit bleibt die Anfrage offen, bis entweder eine Nachricht eintrifft oder der Timeout abläuft. Sobald die Antwort zurückkommt, startet mein Code sofort die nächste Abfrage. So entsteht ein kontinuierlicher Fluss, ohne dass unnötig viele leere Anfragen geschickt werden. Long Polling eignet sich besonders für lokale Tests oder einfache Setups ohne feste Serverinfrastruktur.
Webhook
Für den Produktivbetrieb ist ein Webhook oft die bessere Wahl. Dabei registriere ich eine öffentlich erreichbare HTTPS-URL bei Telegram. Kommt eine neue Nachricht, ruft Telegram automatisch diese Adresse auf und übergibt die Nachricht per POST. Mein Backend kann sofort darauf reagieren, ohne ständig selbst Abfragen stellen zu müssen. Ein gültiges SSL-Zertifikat ist dabei Pflicht.

Wenn eine Nachricht empfangen wurde, prüft mein Code, ob der Inhalt mit „/wetter“ übereinstimmt. Nur in diesem Fall wird eine Aktion ausgelöst. Alle anderen Nachrichten werden ignoriert.

Im nächsten Schritt ruft mein Backend eine externe Schnittstelle auf. In meinem Fall nutze ich die OpenWeatherMap API, die aktuelle Wetterdaten bereitstellt. Mit den Koordinaten für Düsseldorf sende ich eine Anfrage an den Endpunkt für aktuelle Wetterinformationen. Die Antwort kommt im JSON-Format zurück und enthält Werte wie Temperatur, Wetterbeschreibung, Luftfeuchtigkeit oder Windgeschwindigkeit.

Diese Daten bereite ich anschließend in einen lesbaren Text auf und sende ihn über die Methode sendMessage wieder an den Benutzer zurück. Der Nutzer bekommt also das Gefühl, direkt den Bot nach dem Wetter zu fragen, obwohl im Hintergrund mein Backend die externe API anspricht und die Informationen zurückliefert.

Auf diese Weise wird aus einem simplen Bot, der nur Nachrichten entgegennimmt und zurückgibt, eine kleine Anwendung mit echtem Mehrwert. Der Prozess lässt sich beliebig erweitern, etwa indem man statt festgelegter Koordinaten die Stadt aus der Nutzereingabe ausliest und dynamisch an die Wetter-API übergibt.

import requests
import time

API_BOT_TOKEN = "...."
OPENWEATHERMAP_API_KEY = "...."  # OpenWeatherMap API Key
BASE_URL = f"https://api.telegram.org/bot{API_BOT_TOKEN}"

def get_updates(offset=None):
    url = f"{BASE_URL}/getUpdates"
    params = {"timeout": 30, "offset": offset}
    resp = requests.get(url, params=params)
    return resp.json()

def send_message(chat_id, text):
    url = f"{BASE_URL}/sendMessage"
    payload = {"chat_id": chat_id, "text": text}
    requests.post(url, json=payload)

def get_weather():
    url = f"https://api.openweathermap.org/data/2.5/weather?lat=51.2277&lon=6.7735&appid={OPENWEATHERMAP_API_KEY}&units=metric&lang=de"
    resp = requests.get(url).json()
    temp = resp["main"]["temp"]
    desc = resp["weather"][0]["description"]
    return f"In Düsseldorf sind es {temp}°C mit {desc}."

def main():
    offset = None
    while True:
        updates = get_updates(offset)
        for update in updates.get("result", []):
            offset = update["update_id"]   1
            message = update.get("message", {})
            chat_id = message.get("chat", {}).get("id")
            text = message.get("text", "")

            if text and text.lower() in ["/wetter", "wetter"]:
                try:
                    weather_info = get_weather()
                    send_message(chat_id, weather_info)
                    print(f"Wetterdaten an Chat {chat_id} gesendet")
                except Exception as e:
                    send_message(chat_id, "Fehler beim Abrufen der Wetterdaten.")
                    print("Fehler:", e)

        # kleine Pause, um Telegram-Server nicht zu überlasten
        time.sleep(1)

if __name__ == "__main__":
    main()

Auf diesem Bild ist das Ergebnis des zuvor gezeigten Codes zu sehen. Nachdem der Befehl /wetter an den Bot gesendet wurde, antwortet dieser mit den aktuellen Wetterdaten für Düsseldorf.

Mit den gezeigten Schritten ist der Grundstein gelegt, um einen Telegram Bot über die Bot API mit externer Logik zu verbinden. Der Bot selbst ist nur die Schnittstelle, die Nachrichten entgegennimmt und weiterleitet. Die eigentliche Intelligenz liegt im Backend, das entscheidet, ob auf eine Eingabe wie /wetter reagiert wird und wie die Antwort aussieht.

Das Prinzip ist klar: Eingehende Nachrichten abholen, prüfen ob ein relevanter Befehl enthalten ist, externe Datenquellen ansprechen und die Ergebnisse zurückgeben. Alles Weitere ist vor allem Fleißarbeit in der Implementierung, also zusätzliche Befehle anlegen, Antworten strukturieren, Fehlerbehandlung einbauen und den Code robuster machen. Damit steht bereits das Fundament, um aus einem simplen Beispiel eine vollwertige Anwendung zu entwickeln.