Mein Python-Bot: Schnelle Einrichtung mit der Telegram API

Alright, Leute, Marcus Rivera hier, zurück auf ai7bot.com, und heute gehen wir direkt in etwas, das in meinen Entwicklerkreisen oft diskutiert wird, besonders wenn ich versuche, einen schnellen Bot ohne viel Aufwand zum Laufen zu bringen. Wir reden über die oft unterschätzte, manchmal übersehene, aber immer präsente Telegram Bot API. Konkret möchte ich darüber sprechen, wie man in wenigen Minuten mit Python und der Telegram Bot API einen einfachen, aber überraschend leistungsstarken Bot zum Laufen bringt, ohne einen vollwertigen Webserver oder komplexe Bereitstellungen zu benötigen.

Ja, ich weiß. „Telegram Bots“ mag für einige von euch ein bisschen wie 2018 klingen, aber hört mir zu. Während Discord-Bots viel Aufmerksamkeit bekommen (und das aus gutem Grund, ich habe genug davon gebaut), gibt es einen sweet spot für Telegram, wenn man etwas Persönliches, Schnelles und Hochgradig Interaktives mit minimalem Aufwand benötigt. Denkt mal darüber nach: ein Überwachungsbot für euren Heimserver, ein schnelles Tool für eure Familiengruppe oder sogar ein einfaches Benachrichtigungssystem für eure Handelsstrategie. Dafür benötigt man nicht immer einen Docker-Container und Kubernetes. Manchmal ist ein Python-Skript, das auf einem Raspberry Pi oder sogar in einer Shared Hosting-Umgebung läuft, alles, was man braucht, und genau da glänzt Telegram wirklich.

Meine eigene Reise mit diesem Thema wurde vor ein paar Monaten neu entfacht. Ich versuchte, einen kleinen Bot für ein lokales Gemeinschaftsprojekt zu erstellen – im Wesentlichen eine einfache Möglichkeit für Mitglieder, um ein Update zu bestimmten Projektmeilensteinen anzufordern. Ich schaute mir Discord an, aber der Aufwand, Intents, Berechtigungen einzurichten und möglicherweise komplexe Serverinteraktionen zu bewältigen, fühlte sich für das, was im Grunde einen einseitigen Informationsaustausch mit einer einfachen Abfrage darstellt, übertrieben an. Ich erinnerte mich an einen alten Telegram-Bot, den ich vor Jahren zum Tracking von Kaffeebestellungen gebaut hatte (fragt nicht), und dachte: „Warum nicht?“ Die Einfachheit der API, besonders ihr Long-Polling-Mechanismus, hat mich wieder begeistert. Das bedeutete, dass ich einen Webserver nicht ins Internet exposen musste, was ein großer Sicherheits- und Bereitstellungsgewinn für kleine, persönliche Projekte ist.

Heute werden wir einen „Quick-Query“-Telegram-Bot erstellen. Dieser Bot wird es den Benutzern im Wesentlichen ermöglichen, nach vordefinierten Informationen zu fragen und als eine super einfache FAQ oder Datenabfragesystem zu fungieren. Wir verwenden Python und die python-telegram-bot Bibliothek, die meiner Meinung nach die Interaktion mit der Telegram Bot API zu einem Vergnügen macht.

Warum Telegrams Long-Polling für kleine Bots immer noch toll ist

Lasst uns klar sein: Telegram bietet zwei Hauptwege, um Updates von eurem Bot zu erhalten: Webhooks und Long Polling. Webhooks sind großartig, wenn man einen öffentlichen Server hat, der HTTP-POST-Anfragen von Telegram empfangen kann. Sie sind effizient, da Telegram Updates sofort an euch sendet, wenn sie geschehen. Wenn ihr jedoch keine öffentliche IP habt oder nicht mit Reverse Proxies, SSL-Zertifikaten und dem Freischalten von Ports umgehen wollt, wird es mit Webhooks kompliziert.

Kommen wir zum Long Polling. Bei Long Polling macht euer Bot-Skript eine Anfrage an die Telegram-Server und sagt im Wesentlichen: „Hey, gibt es neue Nachrichten für mich?“ Telegram hält diese Verbindung eine Weile offen (standardmäßig bis zu 60 Sekunden). Wenn während dieser Zeit eine neue Nachricht eingeht, sendet Telegram sie sofort zurück. Wenn nicht, läuft die Verbindung schließlich ab und euer Skript macht einfach eine weitere Anfrage. Es ist wie wiederholt an eine Tür zu klopfen und zu warten, aber die Person drinnen antwortet super schnell, wenn sie euch hört. Der Vorteil hier ist, dass euer Skript die Verbindung initiiert, was bedeutet, dass es fast überall mit Internetzugang laufen kann – auf eurem Laptop, einem billigen VPS oder sogar einem Raspberry Pi, der im Schrank verstaut ist. Keine Notwendigkeit für Portweiterleitungen oder irgendetwas ins wilde Internet zu exponieren.

Einrichtung eures Telegram-Bots: Die Grundlagen

Bevor wir Code schreiben, braucht ihr ein Bot-Token. Das ist die Identität eures Bots und der Schlüssel zur Interaktion mit der Telegram API.

1. Öffnet Telegram und sucht nach @BotFather.
2. Startet einen Chat mit BotFather und sendet den Befehl /newbot.
3. BotFather wird nach einem Namen für euren Bot fragen (z. B. „AI7Bot Helper“).
4. Dann fragt er nach einem Benutzernamen (muss mit „bot“ enden, z. B. „AI7BotHelper_bot“).
5. Sobald ihr diese Informationen bereitstellt, gibt euch BotFather ein HTTP-API-Token. Es sieht ungefähr so aus: 1234567890:ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghij. Haltet dieses Token geheim! Wenn jemand es erhält, kann er euren Bot steuern.

Das war’s für die Telegram-Seite! Ganz einfach, oder?

Programmierung unseres Quick-Query-Bots

Wir verwenden Python und die python-telegram-bot Bibliothek. Zuerst stellt sicher, dass ihr sie installiert habt:

pip install python-telegram-bot==20.X # Nutzt die neueste stabile Hauptversion

Ich verwende Version 20.x für dieses Beispiel, die einige schöne moderne Async-Funktionen hat. Wenn ihr auf einer älteren Version seid, könnte sich die Syntax leicht unterscheiden, also empfehle ich, zu aktualisieren.

Schritt 1: Die grundlegende Struktur und Imports

Lasst uns mit dem grundlegenden Boilerplate für eine python-telegram-bot Anwendung beginnen.

import asyncio
import logging
import os # Für Umgebungsvariablen

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

# Log-Einrichtung
logging.basicConfig(
 format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 level=logging.INFO
)
logger = logging.getLogger(__name__)

# --- Konfiguration ---
# Es ist gute Praxis, euer Bot-Token nicht im Code selbst zu belassen.
# Wir verwenden eine Umgebungsvariable.
BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")

if not BOT_TOKEN:
 logger.error("TELEGRAM_BOT_TOKEN Umgebungsvariable nicht gesetzt. Beende.")
 exit(1)

# --- Definiere unsere Abfragedaten ---
# Hier lebt das Wissen unseres Bots.
QUERY_DATA = {
 "hello": "Hallo! Ich bin euer AI7Bot Quick-Query-Helfer.",
 "status": "Alle Systeme nominal für AI7Bot.com!",
 "features": "Ich kann euch über 'hello', 'status' und 'features' erzählen. Probiert einfach, mir etwas Konkretes zu fragen!",
 "marcus": "Marcus ist der Kopf hinter ai7bot.com und tüftelt immer an neuen Bot-Ideen.",
 "date": f"Das heutige Datum ist 2026-03-12. (Für dieses Beispiel fest codiert, könnte aber dynamisch sein!)"
}

# --- Handler-Funktionen ---

async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Sendet eine Begrüßungsnachricht, wenn der /start-Befehl ausgeführt wird."""
 user = update.effective_user
 await update.message.reply_html(
 f"Hey, {user.mention_html()}! 👋 Ich bin euer Quick-Query-Bot. "
 "Fragt mich nach 'hello', 'status', 'features', 'marcus' oder 'date'."
 )

async def query_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Reagiert auf Benutzeranfragen basierend auf vordefinierten Daten."""
 user_message = update.message.text.lower().strip()
 logger.info(f"Anfrage von {update.effective_user.username} erhalten: {user_message}")

 response = QUERY_DATA.get(user_message, "Entschuldigung, ich habe keine Informationen dazu. Probiert 'features' aus, um zu sehen, was ich weiß!")
 await update.message.reply_text(response)

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Sendet eine Hilfenachricht, wenn der /help-Befehl ausgeführt wird."""
 await update.message.reply_text(
 "Ich bin ein einfacher Quick-Query-Bot! "
 "Ihr könnt mich nach vordefinierten Themen wie 'hello', 'status', 'features', 'marcus' oder 'date' fragen.\n"
 "Tippt einfach eure Anfrage direkt ein."
 )

async def echo_unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Echot unbekannte Nachrichten zurück und fordert zur Hilfe auf."""
 await update.message.reply_text("Das habe ich nicht verstanden. Versucht '/help', um zu sehen, was ich tun kann.")

async def main() -> None:
 """Startet den Bot."""
 application = Application.builder().token(BOT_TOKEN).build()

 # Registriere Handler
 application.add_handler(CommandHandler("start", start_command))
 application.add_handler(CommandHandler("help", help_command))
 
 # Nachrichten-Handler für unsere Anfragen - passt auf jede Textnachricht zu,
 # die kein Befehl ist.
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, query_handler))

 # Fängt alle unbekannten Nachrichten (nicht-Befehle, die nicht vom query_handler behandelt werden)
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo_unknown)) # Dies benötigt möglicherweise eine sorgfältige Anordnung
 # Für jetzt, wenn query_handler nicht passt, wird es hierher gelangen.
 # Ein besserer Ansatz für allgemeine unbekannte Nachrichten wäre, dies NACH dem query_handler zu setzen
 # und sicherzustellen, dass query_handler einen spezifischeren Filter hat, falls nötig.
 # Für dieses einfache Beispiel wird query_handler alle nicht-Befehlstexte verarbeiten und antworten.

 logger.info("Bot startet im Long Polling-Modus...")
 application.run_polling(allowed_updates=Update.ALL_TYPES) # Beginnt mit dem Abfragen nach Updates

if __name__ == "__main__":
 asyncio.run(main())

Eine kurze Anmerkung zur Reihenfolge des MessageHandler: Die python-telegram-bot Bibliothek bearbeitet Handler in der Reihenfolge, in der sie hinzugefügt werden. In unserem Beispiel ist query_handler darauf ausgelegt, jede Textnachricht zu erfassen, die kein Befehl ist. Wenn eine Anfrage passt, antwortet sie. Wenn sie nicht mit unseren QUERY_DATA übereinstimmt, antwortet sie trotzdem mit einer „Entschuldigung, ich habe keine Informationen…“-Nachricht. Daher könnte der echo_unknown Handler, der `filters.TEXT & ~filters.COMMAND` erfasst, möglicherweise nicht unbedingt als separater Handler erforderlich sein, wenn `query_handler` bereits alle solchen Fälle mit einer Rückfallantwort behandelt. Ich habe ihn mit einem Kommentar belassen, um zu verdeutlichen, wie ihr ihn später für komplexeres Routing verwenden könnt, aber für dieses spezifische Beispiel ist der `query_handler` für Textnachrichten recht gründlich.

Schritt 2: Führen Sie Ihren Bot aus

Bevor ihr ihn ausführt, müsst ihr euer Bot-Token als Umgebungsvariable festlegen. Auf Linux/macOS:

export TELEGRAM_BOT_TOKEN="DEIN_BOT_TOKEN_HIER"
python your_bot_script.py

Unter Windows (Eingabeaufforderung):

set TELEGRAM_BOT_TOKEN="DEIN_BOT_TOKEN_HIER"
python your_bot_script.py

Ersetze DEIN_BOT_TOKEN_HIER mit dem tatsächlichen Token, den du von BotFather erhalten hast. Führe dann einfach dein Python-Skript aus.

Öffne Telegram, suche nach dem Benutzernamen deines Bots und starte einen Chat. Versuche, /start, dann hello, status oder eines der in QUERY_DATA definierten Schlüsselwörter zu senden. Du wirst sehen, wie dein Bot fast sofort antwortet!

Erweiterung deines Quick-Query Bots: Praktische Ideen

Dieses einfache Framework ist unglaublich flexibel. Hier sind einige Möglichkeiten, wie ich dieses Muster verwendet habe oder in Betracht gezogen habe zu verwenden:

1. Serverstatusüberwachung

Anstatt "Alle Systeme nominal..." fest einzugeben, könnte der Bot eine schnelle Überprüfung durchführen. Zum Beispiel, wenn du einen lokalen Server überwachst:

# Innerhalb von query_handler, wenn user_message == "server_status":
import subprocess

async def get_server_status():
 try:
 # Beispiel: Überprüfen, ob ein Dienst läuft (z.B. Nginx)
 result = subprocess.run(['systemctl', 'is-active', 'nginx'], capture_output=True, text=True, check=True)
 if "active" in result.stdout:
 return "Nginx läuft! ✅"
 else:
 return "Nginx ist nicht aktiv. ❌"
 except subprocess.CalledProcessError:
 return "Nginx-Status konnte nicht überprüft werden. Ist 'systemctl' verfügbar?"
 except Exception as e:
 return f"Ein Fehler ist aufgetreten: {e}"

# Dann, in deinem query_handler:
if user_message == "server_status":
 response = await get_server_status()
 await update.message.reply_text(response)

Damit kannst du den tatsächlichen Status eines Dienstes direkt über Telegram abfragen. Stell dir vor, das auf einem Raspberry Pi zu Hause einzurichten!

2. Einfacher Erinnerungs-Bot

Du könntest einen Befehl wie /remind me to [task] in [X] minutes hinzufügen. Dies würde das Parsen der Zeit und der Aufgabe beinhalten, und dann die Verwendung von Pythons asyncio.sleep, um zu warten und eine Nachricht zurück an die Chat-ID des Benutzers zu senden.

# (Vereinfachtes Beispiel, Fehlerbehandlung und korrektes Parsen erforderlich)
import re
import asyncio

async def remind_me_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 args = context.args # Hole Argumente nach dem Befehl
 if not args or len(args) < 4 or args[0] != "me" or args[1] != "to" or args[-2] != "in":
 await update.message.reply_text("Benutzung: /remind me to [task] in [X] minutes")
 return

 try:
 delay_minutes = int(args[-1])
 task_parts = args[2:-2]
 task = " ".join(task_parts)

 await update.message.reply_text(f"Okay, ich werde dich daran erinnern, '{task}' in {delay_minutes} Minuten.")
 
 # Chat-ID abrufen, um die Erinnerung später zu senden
 chat_id = update.effective_chat.id 

 # Erinnerung planen
 await asyncio.sleep(delay_minutes * 60) # Minuten in Sekunden umrechnen
 await context.bot.send_message(chat_id=chat_id, text=f"Erinnerung: {task}!")

 except ValueError:
 await update.message.reply_text("Bitte gib eine gültige Anzahl von Minuten an.")
 except Exception as e:
 logger.error(f"Fehler im remind_me_command: {e}")
 await update.message.reply_text("Etwas ist schiefgelaufen mit deiner Erinnerung.")

# In main():
# application.add_handler(CommandHandler("remind", remind_me_command))

Dies verwendet context.bot.send_message, was es deinem Bot ermöglicht, eine Nachricht an eine bestimmte Chat-ID zu senden, selbst wenn dies nicht als Antwort auf eine sofortige Benutzeranfrage geschieht.

Praktische Erkenntnisse für dein nächstes Bot-Projekt

Wenn du etwas Schnelles, Persönliches erstellen möchtest oder einfach nicht die Mühe mit der Servereinrichtung haben willst, empfehle ich Folgendes:

1. Nutze Long Polling für Einfachheit: Für interne Tools, persönliche Assistenten oder kleine Community-Bots ist Long Polling eine fantastische Möglichkeit, um Ports nicht exponieren zu müssen oder mit komplexen Bereitstellungen umzugehen. Dein Bot kann auf nahezu jedem Gerät mit Internetzugang ausgeführt werden.
2. Starte klein mit python-telegram-bot: Diese Bibliothek ist unglaublich gut dokumentiert und macht die Interaktion mit der Telegram-API unkompliziert. Versuche nicht, alles auf einmal zu bauen; beginne mit einem einzelnen Befehl oder einer einfachen Abfrage.
3. Verwende Umgebungsvariablen für Tokens: Hardcode niemals dein Bot-Token. Die Verwendung von os.getenv() ist eine gängige und sichere Praxis.
4. Denke über deinen Anwendungsfall nach: Telegram-Bots sind hervorragend für schnelle Interaktionen, Benachrichtigungen und einfache Datenabfragen geeignet. Wenn du komplexe UI-Elemente, das Teilen von reichhaltigen Medien oder eine tiefe Integration mit anderen Webdiensten benötigst, die ständig öffentliche Endpunkte erfordern, könnten Webhooks oder andere Plattformen besser geeignet sein. Aber für viele Utility-Bots ist Telegram perfekt.
5. Halte es asynchron: Die python-telegram-bot-Bibliothek basiert auf asyncio. Werde vertraut mit async def und await, insbesondere wenn dein Bot Operationen ausführen muss, die Zeit in Anspruch nehmen (wie das Durchführen einer Webanfrage, Überprüfen einer Datenbank oder, wie in unserem Erinnerungsbeispiel, Warten auf eine Verzögerung).

Das sind sie. Ein neuer Blick auf den Bau eines praktischen Telegram-Bots, der die Bereitstellungsprobleme überspringt und direkt dazu bringt, Mehrwert zu liefern. Ich habe diesen Ansatz persönlich als unschätzbar für das Prototyping von Ideen und das Erstellen nützlicher Hilfsmittel empfunden, ohne mich in der Infrastruktur festzufahren. Versuch es, und lass mich wissen, welche Art von Quick-Query-Bots du am Ende baust!

🕒 Published: March 27, 2026