Construye Tu Propio Bot de Telegram para Monitorear Listas Negras de IPv4 en un VPS

Mantener tu dirección IP fuera de las listas negras de spam es crítico para la entregabilidad de correos electrónicos, la reputación del servicio y las operaciones ininterrumpidas. Ya sea que ejecutes un servidor de correo, una plataforma SaaS o una aplicación web, una sola entrada en la lista negra puede bloquear silenciosamente tus correos electrónicos salientes y erosionar la confianza del cliente de la noche a la mañana. En esta guía completa, aprenderás cómo construir e implementar un bot de Telegram completamente funcional que verifique automáticamente cualquier dirección IPv4 contra las principales bases de datos de spam, todo ejecutándose en un VPS confiable.

¿Por qué automatizar la supervisión de listas negras IPv4?

Las verificaciones manuales de listas negras son tediosas y fáciles de olvidar. Al automatizar el proceso a través de un bot de Telegram, obtienes:

• Verificaciones instantáneas bajo demanda — consulta cualquier IP directamente desde tu teléfono o escritorio
• Retroalimentación en tiempo real — resultados entregados dentro de Telegram en segundos
• Cero gastos generales de infraestructura — el bot se ejecuta persistentemente en tu servidor en segundo plano
• Escalabilidad — amplía el bot más adelante con alertas programadas, integraciones de webhook o verificaciones por lotes de múltiples IP

Una IP listada en bases de datos como Spamhaus, SpamCop, StopForumSpam o Blocklist.de puede causar fallos en la entrega de correo electrónico, suspensiones de servicio y daño reputacional. La supervisión proactiva es mucho más económica que el control de daños reactivo.

¿Por qué implementar en un VPS de AlexHost?

Ejecutar un bot de Telegram requiere un servidor que permanezca en línea 24/7, responda rápidamente y proporcione acceso root completo para instalar dependencias personalizadas. AlexHost VPS Hosting ofrece exactamente eso — almacenamiento NVMe SSD para E/S rápida, protección DDoS de nivel empresarial y acceso root completo para que puedas instalar Python, Selenium, controladores de navegador y cualquier otra herramienta sin restricciones.

A diferencia de los entornos compartidos donde los límites de recursos pueden ralentizar el rendimiento de tu bot, un VPS dedicado proporciona asignación consistente de CPU y RAM a tu aplicación. Si prefieres una experiencia de panel de control administrado, VPS con cPanel también está disponible, haciendo que la gestión del servidor sea accesible incluso para quienes no están cómodos con la línea de comandos.

Requisitos previos

Antes de escribir una sola línea de código, asegúrate de que lo siguiente esté en su lugar en tu servidor:

Requisitos del sistema

Instalar librerías de Python

Conéctate a tu VPS vía SSH y ejecuta los siguientes comandos para instalar los paquetes de Python requeridos:

pip install selenium
pip install aiogram==3.4.1

• Selenium — automatiza las interacciones del navegador para extraer resultados de verificación de listas negras de MXToolbox
• aiogram 3.4.1 — un marco moderno y asincrónico para la API de Telegram Bot

Instalar Google Chrome y ChromeDriver (Headless)

Selenium requiere un navegador real para renderizar páginas con mucho JavaScript. Instala Chrome en modo headless en tu servidor 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

Luego instala el ChromeDriver coincidente:

# 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

Paso 1 — Crea tu Bot de Telegram con BotFather

Todo bot de Telegram comienza con BotFather — el bot oficial de Telegram para registrar y gestionar bots.

1.1 Abre Telegram y busca @BotFather (busca la marca de verificación azul oficial).

1.2 Inicia una conversación y envía el comando:

/newbot

1.3 Sigue las indicaciones:

• Ingresa un nombre para mostrar para tu bot (p. ej., IP Blacklist Monitor)
• Ingresa un nombre de usuario único que termine en bot (p. ej., ip_blacklist_monitor_bot)

1.4 BotFather responderá con un mensaje de confirmación similar a:

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.

Copia y guarda este token API de forma segura. Lo necesitarás en el siguiente paso. Nunca lo confirmes en un repositorio público.

Paso 2 — Escribir el Código del Bot

En tu VPS, crea un nuevo archivo Python:

nano ~/my_bot.py

Pega el siguiente código completo y listo para producción:

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())

Guarda y sal (Ctrl+O, Enter, Ctrl+X en nano).

Paso 3 — Configurar el Token del Bot de Forma Segura

Reemplaza YOUR_BOT_TOKEN_HERE en el script con el token que recibiste de BotFather. Para implementaciones en producción, se recomienda encarecidamente usar una variable de entorno en lugar de codificar el token:

export TELEGRAM_BOT_TOKEN="7123456789:AAFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

Luego actualiza la línea de código a:

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

Esto evita la exposición accidental del token si tu código se comparte alguna vez o se controla por versiones.

Paso 4 — Ejecutar el Bot como Servicio en Segundo Plano

Para mantener el bot ejecutándose de forma persistente después de cerrar tu sesión SSH, configúralo como un servicio systemd:

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

Pega la siguiente configuración:

[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

Habilita e inicia el servicio:

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

# Verify it is running
sudo systemctl status ipblacklist-bot

Tu bot ahora se reiniciará automáticamente si falla y se iniciará en cada reinicio del servidor.

Paso 5 — Prueba el Bot

1. Abre Telegram y busca tu bot por su nombre de usuario
2. Envía /start — deberías recibir el mensaje de bienvenida
3. Envía cualquier dirección IPv4 (por ejemplo, 8.8.8.8)
4. En 15–20 segundos, recibirás una lista formateada mostrando en cuáles listas negras está incluida la IP (❌) y cuáles pasó (✅)

Descripción General de la Arquitectura del Código

Consideraciones de Seguridad y Cumplimiento

Ejecutar un bot que interactúa con servicios externos desde un VPS conlleva responsabilidades:

• Protege tu token de bot — trátalo como una contraseña. Rótalo inmediatamente a través de BotFather si se ve comprometido.
• Valida la entrada del usuario — añade validación de formato de dirección IP antes de pasar la entrada del usuario a Selenium para prevenir comportamientos inesperados.
• Rate limiting — considera añadir límites de velocidad por usuario para prevenir el abuso de tu bot y los recursos de tu servidor.
• Mantén las dependencias actualizadas — actualiza regularmente aiogram, selenium y Chrome para parchear vulnerabilidades de seguridad.
• Firewall tu VPS — restringe los puertos de entrada solo a lo necesario (SSH y las conexiones salientes de tu bot).

Si tu infraestructura también maneja correo electrónico, emparejar este bot con un entorno de correo debidamente asegurado es esencial. AlexHost Email Hosting proporciona un entorno gestionado y conforme con políticas anti-spam que reduce el riesgo de que tus IPs de envío aparezcan en listas negras en primer lugar.

Para proyectos que requieren un dominio asegurado con SSL junto con tu infraestructura de bot, AlexHost SSL Certificates y Domain Registration hacen que sea sencillo establecer una presencia web completamente confiable.

Política de Spam y Listas Negras de AlexHost

AlexHost aplica una política estricta contra el spam en toda su red. Cualquier actividad que resulte en la inclusión de IP en listas negras — incluyendo correo electrónico no solicitado en masa, spam en foros o abuso reportado por Spamhaus, SpamCop, StopForumSpam, Blocklist.de o bases de datos similares — está estrictamente prohibida. Los servicios que violen esta política se suspenden de inmediato para proteger la integridad de la infraestructura de red compartida y la reputación de todos los clientes.

Esto hace que el monitoreo proactivo con una herramienta como el bot descrito en esta guía no sea solo útil, sino esencial para la operación responsable del servidor.

Ampliación del Bot — Ideas para Desarrollo Futuro

Una vez que tu bot básico esté en funcionamiento, considera estas mejoras:

• Monitoreo programado — usa apscheduler para verificar automáticamente tus IPs de servidor cada 6 o 24 horas y alertarte solo cuando se detecte un nuevo listado
• Verificaciones de lotes multi-IP — acepta una lista de IPs separadas por comas en un único mensaje
• Registro persistente — almacena resultados de verificación en una base de datos SQLite o PostgreSQL para análisis de tendencias históricas
• Modo webhook — cambia de long polling a webhooks para menor latencia y carga de servidor reducida
• Fuentes de datos adicionales — integra APIs de AbuseIPDB o Spamhaus directamente para resultados más autorizados sin automatización de navegador

Conclusión

Construir un bot de Telegram para monitorear listas negras de IPv4 es un proyecto de automatización práctico y de alto valor que cualquier administrador de sistemas o desarrollador puede completar en una tarde. Con Python, aiogram y Selenium ejecutándose en un AlexHost VPS, obtienes una herramienta de monitoreo persistente y receptiva que entrega resultados directamente a tu cliente de Telegram — sin paneles para verificar, sin búsquedas manuales requeridas.

La gestión proactiva de la reputación de IP protege tu capacidad de entrega de correo electrónico, la confianza de tus clientes y el tiempo de actividad de tu servicio. Implementa este bot hoy, mantén tus dependencias actualizadas y amplíalo con el tiempo a medida que tus necesidades de monitoreo crezcan.