Mein Telegram-Bot hat mir jede Woche Stunden gespart.

Hallo zusammen, Marcus hier von ai7bot.com. Ich hoffe, ihr habt alle eine produktive Woche!

Heute möchte ich auf etwas eingehen, das in letzter Zeit für mich wirklich Zeit gespart hat und ehrlich gesagt, auch ein wenig meinen Verstand gerettet hat: die Nutzung von Telegram-Bots, um diese lästigen, sich wiederholenden Aufgaben zu automatisieren, die in persönlichen Projekten oder sogar in kleinen Team-Setups auftreten. Wir alle haben sie, oder? Die kleinen Dinge, die hier 30 Sekunden und da eine Minute in Anspruch nehmen, aber sich zu einem frustrierenden Teil eures Tages summieren. Bei mir war es immer die Überwachung meiner täglichen Codierungsherausforderungen und die Sicherstellung, dass mein Entwicklungsserver tatsächlich wie erwartet läuft.

Vor einer Weile jonglierte ich mit einigen Nebenprojekten – einem neuen Bot zur Verfolgung meiner täglichen Liegestütze (fragt nicht), einer einfachen Web-App zur Verwaltung meiner ständig wachsenden Liste an Tech-Artikeln, die ich lesen wollte, und natürlich, ai7bot.com aktuell zu halten. Ich fand mich ständig dabei, Protokolle zu überprüfen, Server anzupingen und manuell eine Tabelle mit meinem täglichen Fortschritt beim Liegestütz-Bot zu aktualisieren. Es war nicht harte Arbeit, aber es war *störende* Arbeit. Jedes Mal, wenn ich den Kontext wechselte, selbst für eine Minute, kostete es mich mehr Zeit, wieder in den Fluss zu kommen. Ich wusste, dass es einen besseren Weg geben musste, als 17 Tabs offen zu haben oder ständig mein Terminal zu aktualisieren.

Da erinnerte ich mich an die Macht der Telegram-Bots. Ich hatte zuvor einige für einfache Interaktionen entwickelt, hauptsächlich zum Spaß, aber ich hatte sie nicht wirklich als ernsthafte Automatisierungstools für *meinen eigenen* Workflow betrachtet. Die meisten Leute denken bei Chatbots an Kundendienstmitarbeiter oder Marketingtools, aber ihre wahre Magie, besonders für uns Macher, liegt in der persönlichen Automatisierung. Sie sind wie ein kleiner, engagierter Assistent, der in deiner Chat-App lebt.

Heute möchte ich euch zeigen, wie ich Telegram-Bots nutze, um Serverstatusüberprüfungen und persönliche Aufgabenprotokolle zu automatisieren, und wie ihr ähnliche Prinzipien auf eure eigenen sich wiederholenden Kopfschmerzen anwenden könnt. Wir werden uns darauf konzentrieren, einen einfachen Python-basierten Bot zu erstellen, der euch direkt in euer Telegram-Chat Nachrichten sendet. Keine fancy UIs, keine komplexen Dashboards – nur schnelle, umsetzbare Informationen, wo ihr bereits eure Zeit verbringt.

Warum Telegram-Bots für persönliche Automatisierung?

Bevor wir ins Detail gehen, lasst uns darüber sprechen, warum Telegram so gut für diese Art der Automatisierung geeignet ist:

• Allgegenwart: Wahrscheinlich habt ihr Telegram bereits auf eurem Telefon oder Desktop geöffnet. Benachrichtigungen landen genau dort, wo ihr sie seht.
• Einfachheit: Die Telegram Bot API ist unglaublich einfach. Ihr könnt in wenigen Minuten einen einfachen Bot zum Laufen bringen.
• Reiche Funktionen: Neben einfachem Text könnt ihr Bilder, Dateien, Inline-Tastaturen und sogar benutzerdefinierte Schaltflächen senden. Das eröffnet viele Möglichkeiten für interaktive Automatisierung.
• Kostenlos und zuverlässig: Die Infrastruktur von Telegram ist solide, und das Erstellen von Bots ist kostenlos.
• Privat: Für persönliche Automatisierung seid ihr in der Regel die einzigen, die mit dem Bot interagieren. Das hält die Dinge sicher und übersichtlich.

Ich habe kurz an Discord gedacht, aber für schnelle, persönliche Benachrichtigungen und einfache Interaktionen fühlte sich Telegram leichter und direkter an. Außerdem ist der BotFather-Prozess ein Kinderspiel.

Erste Schritte: Dein erster Telegram-Bot

Wenn ihr noch nie einen Telegram-Bot erstellt habt, macht euch keine Sorgen. Es ist super einfach. Hier ist eine kurze Zusammenfassung:

1. Öffnet Telegram und sucht nach @BotFather.
2. Startet einen Chat mit BotFather und gebt /newbot ein.
3. Befolgt die Aufforderungen: gebt eurem Bot einen Namen (z.B. „MarcusDevMonitorBot“) und einen Benutzernamen (z.B. „MarcusDevMonitor_bot“).
4. BotFather gibt euch einen API Token. Das ist entscheidend! Bewahrt ihn gut auf; er ist wie das Passwort für euren Bot.

Sobald ihr diesen Token habt, seid ihr schon fast am Ziel!

Deine erste Nachricht senden

Um eine Nachricht zu senden, muss euer Bot wissen, an wen er sie senden soll. Das ist eure chat_id. Der einfachste Weg, sie zu erhalten, ist, ein Gespräch mit eurem neuen Bot zu beginnen und dann diese URL in eurem Browser aufzurufen, wobei ihr YOUR_BOT_TOKEN mit eurem tatsächlichen Token ersetzt:

https://api.telegram.org/botYOUR_BOT_TOKEN/getUpdates

Ihr seht eine JSON-Antwort. Sucht nach dem "chat"-Objekt und darin nach dem "id"-Feld. Das ist eure chat_id. Es wird eine lange Zahl sein.

Jetzt lasst uns ein kleines Python-Skript schreiben, um eine Nachricht zu senden:

import requests

BOT_TOKEN = "YOUR_BOT_TOKEN_HERE" # Ersetzt durch das Token eures Bots
CHAT_ID = "YOUR_CHAT_ID_HERE" # Ersetzt durch eure chat_id

def send_telegram_message(message):
 url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
 payload = {
 "chat_id": CHAT_ID,
 "text": message,
 "parse_mode": "Markdown" # Ermöglicht Fett-, Kursivschrift usw.
 }
 try:
 response = requests.post(url, json=payload)
 response.raise_for_status() # Löst eine Ausnahme bei HTTP-Fehlern aus
 print("Nachricht erfolgreich gesendet!")
 except requests.exceptions.RequestException as e:
 print(f"Fehler beim Senden der Nachricht: {e}")

if __name__ == "__main__":
 send_telegram_message("Hallo von deinem neuen Automatisierungsbot! 👋")

Führt dieses Skript aus und ihr solltet eine Nachricht in eurem Telegram-Chat sehen. Ziemlich cool, oder? Diese einfache Funktion ist der Kern all unserer Automatisierung.

Praktisches Beispiel 1: Serververfügbarkeitsüberwachung

Mein größter Schmerzpunkt war immer das Fragen, ob mein Entwicklungsserver noch läuft, besonders bei länger laufenden Aufgaben oder geplanten Jobs. Ich brauchte keine Echtzeitüberwachung auf Millisekundenbasis, sondern nur eine Benachrichtigung, wenn etwas schiefgeht.

So bin ich damit umgegangen: ein einfaches Python-Skript, das eine URL oder einen bestimmten Port anpingt und eine Telegram-Nachricht sendet, wenn es ein Problem feststellt. Ich richtete dieses Skript so ein, dass es alle 15 Minuten über einen Cron-Job auf meinem Server ausgeführt wird.

Das Uptime-Check-Skript

import requests
import socket
import time
from datetime import datetime

# --- Telegram Bot Konfiguration ---
BOT_TOKEN = "YOUR_BOT_TOKEN_HERE"
CHAT_ID = "YOUR_CHAT_ID_HERE"

def send_telegram_message(message):
 url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
 payload = {
 "chat_id": CHAT_ID,
 "text": message,
 "parse_mode": "Markdown"
 }
 try:
 response = requests.post(url, json=payload)
 response.raise_for_status()
 # print("Benachrichtigung gesendet.") # Nur für Debugging kommentieren
 except requests.exceptions.RequestException as e:
 print(f"Fehler beim Senden der Telegram-Nachricht: {e}")

# --- Überwachungslogik ---
def check_website(url):
 try:
 response = requests.get(url, timeout=10) # 10-Sekunden-Timeout
 response.raise_for_status() # Löst bei 4xx/5xx-Fehlern eine Ausnahme aus
 return True, f"Website *{url}* ist ONLINE! (Status: {response.status_code})"
 except requests.exceptions.RequestException as e:
 return False, f"Website *{url}* ist NICHT ONLINE! Fehler: `{e}`"

def check_port(host, port):
 try:
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sock.settimeout(5) # 5-Sekunden-Timeout
 result = sock.connect_ex((host, port))
 if result == 0:
 return True, f"Port *{port}* auf *{host}* ist OFFEN."
 else:
 return False, f"Port *{port}* auf *{host}* ist GESCHLOSSEN. Fehlercode: {result}"
 except socket.error as e:
 return False, f"Fehler beim Überprüfen des Ports *{port}* auf *{host}*: `{e}`"

def main():
 now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
 # Überwache eine Website
 website_url = "https://ai7bot.com" # Ersetzt durch eure URL
 is_up, message = check_website(website_url)
 if not is_up:
 send_telegram_message(f"🚨 *DRINGENDE WARNUNG ({now})* 🚨\n{message}")
 # else:
 # send_telegram_message(f"✅ Website-Check: {message}") # Kommentiert für Erfolgsmeldungen

 # Überwache einen bestimmten Port (z.B. SSH oder einen benutzerdefinierten App-Port)
 server_host = "127.0.0.1" # Oder die öffentliche IP/Hostname eures Servers
 server_port = 22 # Beispiel: SSH-Port
 is_open, port_message = check_port(server_host, server_port)
 if not is_open:
 send_telegram_message(f"🚨 *DRINGENDE WARNUNG ({now})* 🚨\n{port_message}")
 # else:
 # send_telegram_message(f"✅ Port-Check: {port_message}") # Kommentiert für Erfolgsmeldungen

if __name__ == "__main__":
 main()

Einige Dinge sind hier zu beachten:

• Ich benutze requests für HTTP-Checks und socket für Portüberprüfungen. Einfache, standardmäßige Bibliotheken.
• Fehlerbehandlung ist entscheidend. Wir wollen Netzwerkprobleme und Timeouts erfassen.
• Ich habe ein parse_mode="Markdown" zum sendMessage-Payload hinzugefügt, was fettgedruckten Text (*text*) und Code-Blöcke (`code`) in den Nachrichten ermöglicht und die Warnungen viel leichter lesbar macht.
• Ich sende nur eine Benachrichtigung, wenn etwas *nicht online* ist. Alle 15 Minuten eine „alles ist in Ordnung“-Nachricht zu bekommen, wäre nervig. Ich habe jedoch die kommentierten Zeilen belassen, falls du *Erfolgsmeldungen* fürs Debugging oder spezielle Szenarien möchtest.

Den Cron-Job einrichten

Sobald ihr dieses Skript (nennen wir es monitor_bot.py) auf eurem Server habt, müsst ihr es planen. Für Linux-Server ist cron euer Freund:

1. Speichert das Skript (z.B. in /home/youruser/bots/monitor_bot.py).
2. Öffnet eure Crontab zur Bearbeitung: crontab -e
3. Fügt eine Zeile wie diese hinzu, um es alle 15 Minuten auszuführen:

   */15 * * * * /usr/bin/python3 /home/youruser/bots/monitor_bot.py >> /home/youruser/bots/monitor_log.txt 2>&1

   Dies teilt cron mit, euer Skript alle 15 Minuten mit python3 auszuführen und alle Ausgaben (einschließlich Fehler) in eine Protokolldatei zu leiten, was super hilfreich für das Debuggen ist.

Jetzt, wenn meine Website oder ein kritischer Port ausfällt, bekomme ich sofort eine Benachrichtigung auf meinem Telefon. Kein manuelles Überprüfen mehr, kein mehr „habe ich diesen Dienst vergessen neu zu starten?“-Panik.

Praktisches Beispiel 2: Einfache tägliche Aufgabenprotokollierung

Neben der Serverüberwachung nutze ich auch einen Bot für ein sehr einfaches persönliches Protokollierungssystem. Erinnerst du dich an das tägliche Nachverfolgen von Liegestützen? Oder darauf, wie viele Artikel ich diese Woche für ai7bot.com geschrieben habe?

Ich habe einen Bot erstellt, der es mir ermöglicht, einen schnellen Befehl wie /log article_written oder /log 50_pushups zu senden, und es wird das in eine einfache Textdatei oder ein Google Sheet hinzugefügt. Der Einfachheit halber bleiben wir für dieses Beispiel bei einer Textdatei, aber die Erweiterung auf die Google Sheet API ist definitiv machbar.

Für dies benötigen wir ein stärkeres Bot-Framework als nur das Senden von Nachrichten. Ich verlasse mich normalerweise auf python-telegram-bot für alles Interaktive. Es verarbeitet eingehende Nachrichten, Befehle und Antworten viel eleganter.

Installation von python-telegram-bot

pip install python-telegram-bot --pre

Der --pre ist wichtig, da die Bibliothek sich derzeit im Vorabveröffentlichungszustand für Version 20 befindet, die einige umfangreiche Änderungen enthält, aber im Allgemeinen besser ist.

Das Skript für den Aufgabenprotokollierungsbot

import logging
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters
from datetime import datetime
import os

# --- Konfiguration ---
BOT_TOKEN = "DEIN_BOT_TOKEN_HIER"
CHAT_ID = int("DEIN_CHAT_ID_HIER") # Stelle sicher, dass dies eine Ganzzahl für den Vergleich ist
LOG_FILE = "daily_tasks.log"

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

# --- Bot-Befehle ---
async def start(update: Update, context):
 """Sendet eine Begrüßungsnachricht, wenn der Befehl /start verwendet wird."""
 user = update.effective_user
 await update.message.reply_html(
 f"Hi {user.mention_html()}! Sende mir /log gefolgt von deiner Aufgabe (z.B. `/log wrote_blog_post`)."
 )

async def log_task(update: Update, context):
 """Protokolliert eine Aufgabe in einer Datei."""
 # Stelle sicher, dass nur der autorisierte Benutzer Aufgaben protokollieren kann
 if update.effective_chat.id != CHAT_ID:
 logger.warning(f"Unbefugter Zugriffsversuch von chat_id: {update.effective_chat.id}")
 await update.message.reply_text("Entschuldigung, ich bin ein privater Bot nur für Marcus! 🤫")
 return

 if not context.args:
 await update.message.reply_text("Verwendung: `/log deine_aufgabenbeschreibung`")
 return

 task_description = " ".join(context.args)
 timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

 try:
 with open(LOG_FILE, "a") as f:
 f.write(f"{timestamp} | {task_description}\n")
 await update.message.reply_text(f"Aufgabe protokolliert: `{task_description}`")
 logger.info(f"Protokollierte Aufgabe für {update.effective_user.first_name}: {task_description}")
 except IOError as e:
 await update.message.reply_text(f"Fehler beim Protokollieren der Aufgabe: `{e}`")
 logger.error(f"Fehler beim Schreiben in die Protokolldatei: {e}")

async def echo(update: Update, context):
 """Echot jede Textnachricht, die nicht als Befehl erkannt wird."""
 # Echo nur für den autorisierten Benutzer
 if update.effective_chat.id == CHAT_ID:
 await update.message.reply_text(f"Meintest du, /log zu verwenden? Ich habe erhalten: `{update.message.text}`")
 else:
 await update.message.reply_text("Ich antworte nur auf Befehle von meinem Besitzer.")


async def error_handler(update: Update, context):
 """Protokolliert den Fehler und sendet eine Nachricht an den Benutzer."""
 logger.error(f"Update {update} verursachte Fehler {context.error}")
 if update.effective_chat:
 await update.effective_chat.send_message(
 f"Ein Fehler ist aufgetreten: `{context.error}`. Bitte versuche es erneut oder überprüfe die Protokolle."
 )

def main():
 """Starte den Bot."""
 application = Application.builder().token(BOT_TOKEN).build()

 # Handler registrieren
 application.add_handler(CommandHandler("start", start))
 application.add_handler(CommandHandler("log", log_task))

 # Protokolliere alle Fehler
 application.add_error_handler(error_handler)

 # Bei Nicht-Befehlsnachrichten, echo die Nachricht (nur für autorisierten Chat)
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

 # Führe den Bot aus, bis der Benutzer Strg-C drückt
 logger.info("Bot gestartet. Drücke Strg-C, um zu stoppen.")
 application.run_polling(allowed_updates=Update.ALL_TYPES)

if __name__ == "__main__":
 main()

Lass uns einige wichtige Teile dieses Logger-Bots aufschlüsseln:

• Application.builder().token(BOT_TOKEN).build(): So initialisierst du den Bot mit python-telegram-bot.
• CommandHandler("start", start): Dies sagt dem Bot, dass die start-Funktion aufgerufen werden soll, wenn jemand den Befehl /start sendet.
• log_task Funktion: Das ist der Kern. Sie nimmt alles, was nach /log folgt, verbindet es zu einem einzelnen String, fügt einen Zeitstempel hinzu und hängt es an daily_tasks.log an.
• CHAT_ID Autorisierung: Wichtig ist, dass ich eine Überprüfung hinzugefügt habe if update.effective_chat.id != CHAT_ID:. Das stellt sicher, dass *nur mein spezifischer Chat* mit den Protokollierungsfunktionen interagieren kann. Du willst nicht, dass fremde Leute Aufgaben in deine persönliche Datei protokollieren!
• MessageHandler(filters.TEXT & ~filters.COMMAND, echo): Das ist ein Auffangmechanismus für alle Textnachrichten, die keine Befehle sind. Ich benutze es, um mich sanft an die korrekte Verwendung zu erinnern (oder andere zu warnen).

Um diesen Bot auszuführen, führe einfach das Python-Skript aus: python3 logger_bot.py. Er bleibt im Hintergrund aktiv und hört auf deine Nachrichten. Für eine nachhaltigeren Aufbau würdest du dies mit einem Prozessmanager wie systemd oder supervisor auf deinem Server ausführen, um sicherzustellen, dass er neu startet, falls er abstürzt.

Jetzt, wenn ich einen Artikel fertig geschrieben habe, tippe ich einfach /log finished_ai7bot_article_telegram_automation in meinen Telegram-Chat, und es wird protokolliert. Später kann ich einfach cat daily_tasks.log auf meinem Server eingeben, um eine Zusammenfassung zu sehen. Das ist so viel weniger Aufwand, als ein Spreadsheet oder eine separate App zu öffnen.

Umsetzbare Erkenntnisse für deine eigene Bot-Automatisierung

Ich hoffe, diese Beispiele regen einige Ideen bei dir an. Die Schönheit der persönlichen Automatisierung mit Bots ist, dass sie nicht komplex oder für Unternehmen geeignet sein muss. Hier ist, was ich empfehle:

1. Identifiziere deine persönlichen “Papercuts”

   Was sind die kleinen, sich wiederholenden Aufgaben, die deine Konzentration rauben? Stunden protokollieren, bestimmte API-Endpunkte überprüfen, benachrichtigt werden, wenn ein geplantes Skript fertig ist, kleine Kennzahlen verfolgen? Mach eine Liste.

2. Beginne klein und einfach

   Versuche nicht, am ersten Tag einen vollwertigen KI-Assistenten zu erstellen. Beginne mit dem Senden einer einzelnen Nachricht, wenn ein spezifisches Ereignis eintritt. Mein Servermonitor fing einfach damit an, “Server ist down!” zu senden, wenn ein Ping fehlschlug. Erweitere das von dort aus.

3. Nutze vorhandene Bibliotheken

   Python mit requests und python-telegram-bot deckt eine Vielzahl von Möglichkeiten ab. Erfinde das Rad nicht neu für API-Interaktionen oder Bot-Verwaltung.

4. Sicherheit und Privatsphäre priorisieren

   Besonders für persönliche Bots stelle sicher, dass dein API-Token nicht offen gelegt wird. Für Bots, die mit sensiblen Informationen umgehen oder Aktionen steuern, implementiere Chat-ID-Überprüfungen, um sicherzustellen, dass nur *du* damit interagieren kannst, wie im Logger-Beispiel gezeigt.

5. Denk über Benachrichtigungen hinaus

   Obwohl Benachrichtigungen großartig sind, überlege, wie du einfache Interaktionen hinzufügen könntest. Könnte dein Bot einen Serverneustart auslösen? Einen schnellen Bericht abrufen? Eine Einstellung umschalten? Die Bibliothek python-telegram-bot macht es ziemlich einfach, Befehle hinzuzufügen.

6. Verwende einen Prozessmanager für Langlebigkeit

   Wenn dein Bot kontinuierlich läuft (wie der Logger-Bot), verwende systemd (unter Linux) oder ein Tool wie supervisor, um sicherzustellen, dass er neu startet, wenn er abstürzt und zuverlässig im Hintergrund läuft.

Diese kleinen Bots zu bauen, hat meinen Entwicklungsworkflow wirklich reibungsloser und weniger ablenkend gemacht. Es ist ein Beweis dafür, wie selbst einfache Automatisierungen mentalen Raum für interessantere, kreative Arbeit schaffen können. Also, schnapp dir dein BotFather-Token, identifiziere eine kleine Nervensäge und fang an zu bauen!

Lass mich in den Kommentaren wissen, welche Art von persönlicher Automatisierung du mit Telegram-Bots erstellt hast oder planst zu erstellen. Ich bin immer auf der Suche nach neuen Ideen!

Viel Spaß beim Bot-Bauen!

Marcus Rivera

ai7bot.com

🕒 Published: March 30, 2026