Construisez votre propre bot Telegram pour surveiller les listes noires IPv4 sur un VPS

Garder votre adresse IP hors des listes noires de spam est essentiel pour la délivrabilité des emails, la réputation du service et les opérations sans interruption. Que vous gériez un serveur de courrier, une plateforme SaaS ou une application web, une seule entrée sur liste noire peut bloquer silencieusement vos emails sortants et éroder la confiance des clients du jour au lendemain. Dans ce guide complet, vous apprendrez à construire et déployer un bot Telegram entièrement fonctionnel qui vérifie automatiquement toute adresse IPv4 par rapport aux principales bases de données de spam — le tout fonctionnant sur un VPS fiable.

Pourquoi automatiser la surveillance des listes noires IPv4 ?

Les vérifications manuelles des listes noires sont fastidieuses et faciles à oublier. En automatisant le processus via un bot Telegram, vous obtenez :

• Vérifications instantanées à la demande — interrogez n’importe quel IP directement depuis votre téléphone ou votre ordinateur de bureau
• Retours en temps réel — résultats livrés dans Telegram en quelques secondes
• Zéro surcharge d’infrastructure — le bot s’exécute de manière persistante sur votre serveur en arrière-plan
• Scalabilité — étendez le bot ultérieurement avec des alertes programmées, des intégrations webhook ou des vérifications par lots multi-IP

Un IP répertorié sur des bases de données telles que Spamhaus, SpamCop, StopForumSpam ou Blocklist.de peut entraîner des défaillances de livraison d’e-mails, des suspensions de service et des dommages réputationnels. La surveillance proactive est bien moins coûteuse que la gestion réactive des dommages.

Pourquoi déployer sur un VPS AlexHost ?

L’exécution d’un bot Telegram nécessite un serveur qui reste en ligne 24/7, répond rapidement et fournit un accès root complet pour installer des dépendances personnalisées. AlexHost VPS Hosting offre exactement cela — stockage NVMe SSD pour des E/S rapides, protection DDoS de qualité entreprise et accès root complet pour que vous puissiez installer Python, Selenium, les pilotes de navigateur et tout autre outil sans restrictions.

Contrairement aux environnements partagés où les limites de ressources peuvent ralentir les performances de votre bot, un VPS dédié fournit une allocation CPU et RAM cohérente à votre application. Si vous préférez une expérience de panneau de contrôle géré, VPS avec cPanel est également disponible, rendant la gestion du serveur accessible même pour ceux moins à l’aise avec la ligne de commande.

Prérequis

Avant d’écrire une seule ligne de code, assurez-vous que les éléments suivants sont en place sur votre serveur :

Configuration système requise

Installer les bibliothèques Python

Connectez-vous à votre VPS via SSH et exécutez les commandes suivantes pour installer les packages Python requis :

pip install selenium
pip install aiogram==3.4.1

• Selenium — automatise les interactions du navigateur pour extraire les résultats de vérification de liste noire de MXToolbox
• aiogram 3.4.1 — un framework Python moderne et asynchrone pour l’API Telegram Bot

Installer Google Chrome et ChromeDriver (Headless)

Selenium nécessite un vrai navigateur pour afficher les pages riches en JavaScript. Installez Chrome en mode headless sur votre serveur Linux :

# Install dependencies
sudo apt update
sudo apt install -y wget curl unzip fonts-liberation libappindicator3-1 libasound2 
  libatk-bridge2.0-0 libatk1.0-0 libcups2 libdbus-1-3 libgdk-pixbuf2.0-0 
  libnspr4 libnss3 libx11-xcb1 libxcomposite1 libxdamage1 libxrandr2 
  xdg-utils libgbm1

# Download and install Chrome
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo dpkg -i google-chrome-stable_current_amd64.deb
sudo apt --fix-broken install -y

# Verify installation
google-chrome --version

Installez ensuite le ChromeDriver correspondant :

# Get your Chrome version number first
CHROME_VERSION=$(google-chrome --version | grep -oP 'd+.d+.d+.d+')
CHROME_MAJOR=$(echo $CHROME_VERSION | cut -d. -f1)

# Download matching ChromeDriver
wget "https://chromedriver.storage.googleapis.com/LATEST_RELEASE_${CHROME_MAJOR}" -O latest_release
DRIVER_VERSION=$(cat latest_release)
wget "https://chromedriver.storage.googleapis.com/${DRIVER_VERSION}/chromedriver_linux64.zip"
unzip chromedriver_linux64.zip
sudo mv chromedriver /usr/local/bin/
sudo chmod +x /usr/local/bin/chromedriver

Étape 1 — Créez votre bot Telegram avec BotFather

Chaque bot Telegram commence par BotFather — le bot Telegram officiel pour enregistrer et gérer les bots.

1.1 Ouvrez Telegram et recherchez @BotFather (cherchez la coche bleue vérifiée).

1.2 Démarrez une conversation et envoyez la commande :

/newbot

1.3 Suivez les invites :

• Entrez un nom d’affichage pour votre bot (par exemple, IP Blacklist Monitor)
• Entrez un nom d’utilisateur unique se terminant par bot (par exemple, ip_blacklist_monitor_bot)

1.4 BotFather répondra avec un message de confirmation similaire à :

Done! Congratulations on your new bot.
You will find it at t.me/ip_blacklist_monitor_bot.

Use this token to access the HTTP API:
7123456789:AAFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Keep your token secure and store it safely — it can be used by anyone to control your bot.

Copiez et enregistrez ce jeton API de manière sécurisée. Vous en aurez besoin à l’étape suivante. Ne le validez jamais dans un référentiel public.

Étape 2 — Écrire le Code du Bot

Sur votre VPS, créez un nouveau fichier Python :

nano ~/my_bot.py

Collez le code complet et prêt pour la production suivant :

import asyncio
import time
from aiogram import Bot, Dispatcher, F
from aiogram.filters import CommandStart
from aiogram.types import Message
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options

# ─── Configuration ────────────────────────────────────────────────────────────
BOT_TOKEN = 'YOUR_BOT_TOKEN_HERE'  # Replace with your BotFather token
# ──────────────────────────────────────────────────────────────────────────────

bot = Bot(BOT_TOKEN)
dp = Dispatcher()

def get_chrome_driver():
    """Initialize a headless Chrome driver for server environments."""
    chrome_options = Options()
    chrome_options.add_argument('--headless')
    chrome_options.add_argument('--no-sandbox')
    chrome_options.add_argument('--disable-dev-shm-usage')
    chrome_options.add_argument('--disable-gpu')
    chrome_options.add_argument('--window-size=1920,1080')
    return webdriver.Chrome(options=chrome_options)

def get_results(ip: str) -> list:
    """
    Use Selenium to check an IPv4 address against blacklists via MXToolbox.
    Returns a list of [status, blacklist_name] pairs.
    """
    results = []
    driver = get_chrome_driver()

    try:
        # Navigate to MXToolbox blacklist checker
        url = f"https://mxtoolbox.com/SuperTool.aspx?action=blacklist%3a{ip}&run=toolpage"
        driver.get(url)
        time.sleep(6)  # Allow the page and results to fully load

        # Locate the IP input field and submit the query
        input_field = driver.find_element(By.NAME, 'ctl00$ContentPlaceHolder1$txtInput2')
        input_field.clear()
        input_field.send_keys(ip)
        time.sleep(3)

        search_button = driver.find_element(By.ID, 'btnAction3')
        search_button.click()
        time.sleep(6)  # Wait for results to render

        # Scrape up to 60 status and name columns
        status_results = driver.find_elements(By.CLASS_NAME, 'table-column-Status')[:60]
        name_results = driver.find_elements(By.CLASS_NAME, 'table-column-Name')[:60]

        if len(status_results) == len(name_results):
            for status, name in zip(status_results, name_results):
                results.append([status.text, name.text])
        else:
            print(f"[WARNING] Status/name count mismatch for IP: {ip}")

    except Exception as e:
        print(f"[ERROR] Failed to retrieve results for {ip}: {e}")
    finally:
        driver.quit()

    return results

@dp.message(CommandStart())
async def handle_start(message: Message):
    """Handle the /start command — greet the user and explain usage."""
    await message.answer(
        f"👋 Hello, {message.from_user.first_name}!nn"
        f"Send me any IPv4 address and I will check it against major spam blacklists.nn"
        f"Example: <code>192.168.1.1</code>",
        parse_mode="HTML"
    )

@dp.message(F.text)
async def handle_ip_check(message: Message):
    """Receive an IP address, run the blacklist check, and return formatted results."""
    ip = message.text.strip()
    await message.answer(f"🔍 Checking <code>{ip}</code> against blacklists. Please wait...", parse_mode="HTML")

    loop = asyncio.get_event_loop()
    # Run the blocking Selenium call in a thread pool to avoid blocking the event loop
    raw_results = await loop.run_in_executor(None, get_results, ip)

    if not raw_results:
        await message.answer("⚠️ No results returned. Please verify the IP address and try again.")
        return

    output_lines = []
    blacklisted_count = 0

    for status, name in raw_results:
        if status.strip().upper() == 'OK':
            output_lines.append(f"✅ {name}")
        else:
            output_lines.append(f"❌ {name}")
            blacklisted_count += 1

    summary = f"📊 <b>Results for {ip}</b>n"
    summary += f"🚫 Listed on {blacklisted_count} blacklist(s)nn"
    summary += "n".join(output_lines)

    # Telegram messages have a 4096-character limit — split if necessary
    if len(summary) > 4096:
        for i in range(0, len(summary), 4096):
            await message.answer(summary[i:i+4096], parse_mode="HTML")
    else:
        await message.answer(summary, parse_mode="HTML")

async def main():
    print("✅ Bot is running. Listening for messages...")
    await dp.start_polling(bot)

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

Enregistrez et quittez (Ctrl+O, Enter, Ctrl+X dans nano).

Étape 3 — Configurer le jeton du bot de manière sécurisée

Remplacez YOUR_BOT_TOKEN_HERE dans le script par le jeton que vous avez reçu de BotFather. Pour les déploiements en production, il est fortement recommandé d’utiliser une variable d’environnement au lieu de coder en dur le jeton :

export TELEGRAM_BOT_TOKEN="7123456789:AAFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

Ensuite, mettez à jour la ligne de code en :

import os
BOT_TOKEN = os.environ.get('TELEGRAM_BOT_TOKEN')

Cela empêche l’exposition accidentelle du jeton si votre code est jamais partagé ou contrôlé par version.

Étape 4 — Exécuter le Bot en tant que Service d’Arrière-Plan

Pour maintenir le bot en cours d’exécution de manière persistante après la fermeture de votre session SSH, configurez-le en tant que service systemd :

sudo nano /etc/systemd/system/ipblacklist-bot.service

Collez la configuration suivante :

[Unit]
Description=IPv4 Blacklist Monitor Telegram Bot
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root
ExecStart=/usr/bin/python3 /root/my_bot.py
Restart=on-failure
RestartSec=10
Environment="TELEGRAM_BOT_TOKEN=YOUR_BOT_TOKEN_HERE"

[Install]
WantedBy=multi-user.target

Activez et démarrez le service :

sudo systemctl daemon-reload
sudo systemctl enable ipblacklist-bot
sudo systemctl start ipblacklist-bot

# Verify it is running
sudo systemctl status ipblacklist-bot

Votre bot redémarrera maintenant automatiquement s’il plante et démarrera à chaque redémarrage du serveur.

Étape 5 — Tester le Bot

1. Ouvrez Telegram et recherchez votre bot par son nom d’utilisateur
2. Envoyez /start — vous devriez recevoir le message de bienvenue
3. Envoyez n’importe quelle adresse IPv4 (par exemple, 8.8.8.8)
4. Dans 15–20 secondes, vous recevrez une liste formatée montrant sur quelles listes noires l’IP est répertoriée (❌) et lesquelles elle a réussi (✅)

Aperçu de l’architecture du code

Considérations de sécurité et de conformité

L’exécution d’un bot qui interagit avec des services externes à partir d’un VPS s’accompagne de responsabilités :

• Protégez votre jeton de bot — traitez-le comme un mot de passe. Faites-le tourner immédiatement via BotFather s’il est compromis.
• Validez l’entrée utilisateur — ajoutez une validation du format d’adresse IP avant de transmettre l’entrée utilisateur à Selenium pour éviter un comportement inattendu.
• Limitation de débit — envisagez d’ajouter des limites de débit par utilisateur pour prévenir les abus de votre bot et des ressources de votre serveur.
• Maintenez les dépendances à jour — mettez régulièrement à jour aiogram, selenium et Chrome pour corriger les vulnérabilités de sécurité.
• Pare-feu de votre VPS — limitez les ports entrants à ce qui est nécessaire (SSH et les connexions sortantes de votre bot).

Si votre infrastructure gère également le courrier électronique, l’association de ce bot avec un environnement de messagerie correctement sécurisé est essentielle. AlexHost Email Hosting fournit un environnement géré et conforme aux politiques anti-spam qui réduit le risque que vos adresses IP d’envoi apparaissent sur des listes noires en premier lieu.

Pour les projets qui nécessitent un domaine sécurisé par SSL aux côtés de votre infrastructure de bot, AlexHost SSL Certificates et Domain Registration facilitent l’établissement d’une présence web entièrement fiable.

Politique de Spam et de Liste Noire d’AlexHost

AlexHost applique une politique stricte de non-spam sur l’ensemble de son réseau. Toute activité entraînant un blacklistage d’IP — y compris les emails non sollicités en masse, le spam de forum ou les abus signalés par Spamhaus, SpamCop, StopForumSpam, Blocklist.de ou des bases de données similaires — est strictement interdite. Les services trouvés en violation sont immédiatement suspendus pour protéger l’intégrité de l’infrastructure réseau partagée et la réputation de tous les clients.

Cela rend la surveillance proactive avec un outil comme le bot décrit dans ce guide non seulement utile, mais essentielle pour une exploitation responsable du serveur.

Étendre le Bot — Idées pour le Développement Futur

Une fois que votre bot de base fonctionne, considérez ces améliorations :

• Surveillance programmée — utilisez apscheduler pour vérifier automatiquement vos IPs de serveur toutes les 6 ou 24 heures et vous alerter uniquement lorsqu’une nouvelle inscription est détectée
• Vérifications par lot multi-IP — acceptez une liste d’IPs séparées par des virgules dans un seul message
• Journalisation persistante — stockez les résultats des vérifications dans une base de données SQLite ou PostgreSQL pour l’analyse des tendances historiques
• Mode Webhook — passez du long polling aux webhooks pour une latence plus faible et une charge serveur réduite
• Sources de données supplémentaires — intégrez les APIs d’AbuseIPDB ou Spamhaus directement pour des résultats plus fiables sans automatisation de navigateur

Conclusion

Construire un bot Telegram pour surveiller les listes noires IPv4 est un projet d’automatisation pratique et de grande valeur que tout administrateur système ou développeur peut réaliser en une après-midi. Avec Python, aiogram et Selenium s’exécutant sur un AlexHost VPS, vous obtenez un outil de surveillance persistant et réactif qui fournit des résultats directement à votre client Telegram — pas de tableaux de bord à vérifier, pas de recherches manuelles requises.

La gestion proactive de la réputation des IP protège votre délivrabilité des e-mails, la confiance de vos clients et la disponibilité de votre service. Déployez ce bot dès aujourd’hui, maintenez vos dépendances à jour et étendez-le au fil du temps à mesure que vos besoins de surveillance augmentent.