Ir a la página de inicio
Home / Posts
Compartir en Twitter
Go to Homepage

CÓMO CREAR UN BOT DE TELEGRAM CON PYTHON EN 2025

November 24, 2025

Introducción a la Creación de Bots de Telegram con Python

Los bots de Telegram son herramientas poderosas para automatizar tareas, interactuar con usuarios y ofrecer servicios personalizados dentro de la plataforma de mensajería. En este tutorial, aprenderás a crear un bot de Telegram utilizando Python, un lenguaje de programación versátil y ampliamente utilizado en el desarrollo de aplicaciones. Este artículo está diseñado para programadores y entusiastas de la tecnología que desean implementar un bot funcional, desde la configuración inicial hasta su despliegue, con ejemplos de código claros y actualizados a noviembre de 2025. Exploraremos cómo registrar un bot, configurar el entorno de desarrollo, programar funcionalidades básicas y avanzadas, y mantener el bot en ejecución. Este tutorial se enfoca en un enfoque práctico, con un lenguaje profesional y ejemplos que ilustran cada paso del proceso.

Registro del Bot con BotFather

El primer paso para crear un bot de Telegram es registrarlo utilizando BotFather, un bot oficial de Telegram que facilita la creación y gestión de otros bots. Para comenzar, abre Telegram en tu dispositivo y busca @BotFather en la barra de búsqueda. Inicia una conversación con él enviando el comando /start. A continuación, envía el comando /newbot para iniciar el proceso de creación. BotFather te pedirá que proporciones un nombre para tu bot, que puede ser cualquier texto descriptivo, como “MiBotDePrueba”. Luego, deberás asignar un nombre de usuario único que termine en “Bot” o “bot”, por ejemplo, @MiBotDePrueba. Es importante que el nombre de usuario no esté en uso, ya que Telegram no permite duplicados.

Una vez completado este proceso, BotFather te proporcionará un token de acceso, una cadena alfanumérica que sirve como clave para autenticar tu bot con la API de Telegram. Este token es confidencial y no debe compartirse públicamente. Guárdalo en un lugar seguro, ya que lo necesitarás para programar tu bot. Si deseas personalizar tu bot, BotFather ofrece comandos adicionales como /setabouttext para agregar una descripción o /setuserpic para establecer una imagen de perfil.

# Ejemplo de token de acceso (ficticio, no uses este valor)
TOKEN = "1234567890:AAF1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7"

Configuración del Entorno de Desarrollo

Antes de escribir código, necesitas configurar un entorno de desarrollo adecuado. Asegúrate de tener instalado Python 3.11 o una versión superior, ya que las bibliotecas modernas de Telegram requieren compatibilidad con versiones recientes. Puedes descargar Python desde el sitio oficial y verificar su instalación ejecutando el siguiente comando en tu terminal:

python --version

El próximo paso es instalar la biblioteca python-telegram-bot, que simplifica la interacción con la API de Telegram. Esta biblioteca es una de las más populares para desarrollar bots en Python debido a su facilidad de uso y documentación extensa. Para instalarla, utiliza pip, el administrador de paquetes de Python, ejecutando el siguiente comando:

pip install python-telegram-bot

Es recomendable trabajar en un entorno virtual para aislar las dependencias de tu proyecto. Crea un entorno virtual y actívalo con los siguientes comandos:

python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

Una vez activado el entorno, tu terminal estará configurado para usar las bibliotecas instaladas específicamente para este proyecto, evitando conflictos con otras aplicaciones. Ahora estás listo para comenzar a programar tu bot.

Creación de un Bot Básico

Con el entorno configurado, es hora de escribir el código inicial para tu bot. Crea un archivo llamado bot.py y comienza importando las clases necesarias de la biblioteca python-telegram-bot. El siguiente ejemplo muestra cómo configurar un bot que responde al comando /start con un mensaje de bienvenida:

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

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("¡Hola! Soy tu bot de Telegram. Usa /help para ver los comandos disponibles.")

def main():
    # Reemplaza 'TU_TOKEN' con el token proporcionado por BotFather
    app = Application.builder().token("TU_TOKEN").build()

    # Agrega un manejador para el comando /start
    app.add_handler(CommandHandler("start", start))

    # Inicia el bot en modo polling
    app.run_polling()

if __name__ == "__main__":
    main()

Este código hace lo siguiente: importa las clases necesarias, define una función start que responde al comando /start, y configura la aplicación para escuchar actualizaciones de Telegram mediante polling. El polling es un método en el que el bot consulta continuamente los servidores de Telegram para recibir nuevos mensajes. Para ejecutar el bot, guarda el archivo y corre el siguiente comando:

python bot.py

Abre Telegram, busca tu bot y envía el comando /start. Deberías recibir un mensaje de bienvenida. Si el bot no responde, verifica que el token sea correcto y que no haya errores en la consola.

Manejo de Comandos Adicionales

Para hacer tu bot más interactivo, puedes agregar más comandos. Por ejemplo, implementemos un comando /help que liste las funcionalidades disponibles y un comando /info que proporcione detalles sobre el bot. Modifica el archivo bot.py para incluir estas funciones:

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

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("¡Hola! Soy tu bot de Telegram. Usa /help para ver los comandos disponibles.")

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("Comandos disponibles:\n/start - Inicia el bot\n/help - Muestra esta ayuda\n/info - Información del bot")

async def info(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("Soy un bot creado con Python. Mi propósito es ayudarte con tareas simples. ¡Escribe /help para más detalles!")

def main():
    app = Application.builder().token("TU_TOKEN").build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("help", help_command))
    app.add_handler(CommandHandler("info", info))

    app.run_polling()

if __name__ == "__main__":
    main()

Este código agrega dos nuevos comandos. El comando /help proporciona una lista de comandos disponibles, mientras que /info ofrece una breve descripción del bot. Ejecuta nuevamente el script y prueba los comandos en Telegram. Este enfoque modular te permite expandir fácilmente las funcionalidades del bot añadiendo más manejadores de comandos.

Respuesta a Mensajes de Texto

Además de los comandos, tu bot puede responder a mensajes de texto regulares, lo que lo hace más dinámico. Por ejemplo, puedes programar el bot para que responda con un eco (repitiendo el mensaje del usuario) o para que reaccione a palabras clave específicas. Agrega un manejador de mensajes utilizando MessageHandler y el filtro filters.TEXT para procesar mensajes que no sean comandos:

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

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("¡Hola! Soy tu bot de Telegram. Usa /help para ver los comandos disponibles.")

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(f"Escribiste: {update.message.text}")

def main():
    app = Application.builder().token("TU_TOKEN").build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

    app.run_polling()

if __name__ == "__main__":
    main()

En este ejemplo, el bot responde repitiendo cualquier mensaje de texto que no sea un comando. El filtro ~filters.COMMAND asegura que los comandos (como /start) no activen el manejador de mensajes. Prueba enviando un mensaje como “Hola, bot” y verifica que el bot responde con “Escribiste: Hola, bot”. Este tipo de funcionalidad es útil para crear bots que interactúan de manera conversacional.

Implementación de Webhooks para Producción

El método de polling es ideal para desarrollo y pruebas, pero no es eficiente para bots en producción, ya que consume recursos al consultar constantemente los servidores de Telegram. Una alternativa más robusta es usar webhooks, que permiten a Telegram enviar actualizaciones directamente a tu servidor cuando ocurren eventos, como nuevos mensajes. Configurar webhooks requiere un servidor accesible públicamente con un certificado SSL para conexiones seguras.

Primero, necesitarás un servidor. Plataformas como Heroku, Render o DigitalOcean son opciones populares para alojar bots de Telegram. Asegúrate de que tu servidor tenga un dominio o subdominio con HTTPS habilitado. Luego, modifica tu código para configurar un webhook en lugar de polling. A continuación, se muestra un ejemplo básico de cómo configurar un webhook utilizando la biblioteca python-telegram-bot:

from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes, WebhookUpdate

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("¡Hola! Soy tu bot de Telegram.")

def main():
    app = Application.builder().token("TU_TOKEN").build()

    app.add_handler(CommandHandler("start", start))

    # Configura el webhook
    app.run_webhook(
        listen="0.0.0.0",
        port=8443,
        url_path="/webhook",
        webhook_url="https://tu-dominio.com/webhook"
    )

if __name__ == "__main__":
    main()

En este código, run_webhook configura el bot para escuchar actualizaciones en la URL especificada (https://tu-dominio.com/webhook). Asegúrate de reemplazar tu-dominio.com con el dominio real de tu servidor. Además, necesitarás configurar tu servidor para manejar solicitudes HTTPS en el puerto 8443 (o el puerto que elijas). Si usas una plataforma como Heroku, puedes configurar el webhook automáticamente mediante su CLI o panel de control.

Para probar el webhook, despliega tu código en el servidor y verifica que Telegram pueda enviar actualizaciones. Puedes usar herramientas como ngrok para probar webhooks localmente durante el desarrollo, aunque no es adecuado para producción debido a su naturaleza temporal.

Agregar Funcionalidades Avanzadas

Una vez que tu bot responde a comandos y mensajes, puedes agregar funcionalidades más avanzadas, como enviar imágenes, procesar datos de APIs externas o interactuar con bases de datos. Por ejemplo, supongamos que quieres que tu bot envíe una imagen cuando el usuario escribe la palabra “foto”. Necesitarás una imagen accesible (puede estar almacenada localmente o en una URL) y el método reply_photo para enviarla:

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

async def send_photo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    if update.message.text.lower() == "foto":
        await update.message.reply_photo(photo="https://ejemplo.com/imagen.jpg")

def main():
    app = Application.builder().token("TU_TOKEN").build()

    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, send_photo))

    app.run_polling()

if __name__ == "__main__":
    main()

Este código verifica si el mensaje es “foto” (ignorando mayúsculas) y envía una imagen desde una URL. Puedes expandir esta funcionalidad para enviar diferentes tipos de medios, como videos o documentos, utilizando métodos como reply_video o reply_document.

Otra funcionalidad útil es integrar tu bot con una API externa para proporcionar datos en tiempo real. Por ejemplo, puedes usar la API de OpenWeather para enviar el clima actual cuando el usuario escribe “clima”. Primero, instala la biblioteca requests para realizar solicitudes HTTP:

pip install requests

Luego, modifica tu código para consultar la API de OpenWeather y enviar la respuesta al usuario:

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

async def get_weather(update: Update, context: ContextTypes.DEFAULT_TYPE):
    if update.message.text.lower() == "clima":
        api_key = "TU_CLAVE_API"  # Reemplaza con tu clave de OpenWeather
        city = "Madrid"  # Puedes personalizar la ciudad
        url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
        response = requests.get(url).json()

        if response["cod"] == 200:
            temp = response["main"]["temp"]
            description = response["weather"][0]["description"]
            await update.message.reply_text(f"El clima en {city} es {description} con {temp}°C.")
        else:
            await update.message.reply_text("No pude obtener el clima. Intenta de nuevo.")

def main():
    app = Application.builder().token("TU_TOKEN").build()

    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, get_weather))

    app.run_polling()

if __name__ == "__main__":
    main()

Este código envía el clima de una ciudad específica cuando el usuario escribe “clima”. Para usar esta funcionalidad, regístrate en OpenWeather, obtén una clave API gratuita y reemplaza TU_CLAVE_API con tu clave. Puedes mejorar esta función permitiendo que el usuario especifique la ciudad en el mensaje, por ejemplo, “clima Madrid”.

Gestión de Errores y Depuración

A medida que tu bot crece en complejidad, es fundamental implementar manejo de errores para garantizar su estabilidad. Por ejemplo, las solicitudes a APIs externas pueden fallar debido a problemas de red o límites de cuota. Puedes usar bloques try-except para manejar estas excepciones y notificar al usuario de manera adecuada:

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

async def get_weather(update: Update, context: ContextTypes.DEFAULT_TYPE):
    if update.message.text.lower() == "clima":
        try:
            api_key = "TU_CLAVE_API"
            city = "Madrid"
            url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
            response = requests.get(url).json()

            if response["cod"] == 200:
                temp = response["main"]["temp"]
                description = response["weather"][0]["description"]
                await update.message.reply_text(f"El clima en {city} es {description} con {temp}°C.")
            else:
                await update.message.reply_text("Ciudad no encontrada. Verifica el nombre.")
        except requests.RequestException:
            await update.message.reply_text("Error al conectar con el servicio de clima. Intenta de nuevo más tarde.")

def main():
    app = Application.builder().token("TU_TOKEN").build()

    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, get_weather))

    app.run_polling()

if __name__ == "__main__":
    main()

Este código maneja errores de red y respuestas inválidas de la API, proporcionando mensajes claros al usuario. Además, puedes agregar registros (logging) para depurar problemas en producción. La biblioteca python-telegram-bot incluye soporte para logging, que puedes habilitar agregando las siguientes líneas al inicio de tu script:

import logging

logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    level=logging.INFO
)

Esto generará registros en la consola que te ayudarán a identificar problemas, como errores en la conexión con Telegram o fallos en las funciones del bot.

Despliegue del Bot en un Servidor

Para que tu bot esté disponible las 24 horas, debes desplegarlo en un servidor. Plataformas como Heroku, Render y Railway ofrecen planes gratuitos o de bajo costo ideales para bots de Telegram. A continuación, se describe un flujo básico para desplegar tu bot en Heroku:

  1. Crea una cuenta en Heroku y descarga la CLI de Heroku.
  2. Organiza tu proyecto con la siguiente estructura:
.
├── bot.py
├── requirements.txt
├── Procfile
  1. Crea un archivo requirements.txt con las dependencias:
python-telegram-bot==20.7
requests==2.31.0
  1. Crea un archivo Procfile para indicar cómo ejecutar el bot:
worker: python bot.py
  1. Inicializa un repositorio Git, haz commit de los archivos y crea una nueva aplicación en Heroku:
git init
git add .
git commit -m "Inicializar bot de Telegram"
heroku create nombre-de-tu-app
  1. Despliega el código:
git push heroku main
  1. Escala el proceso worker:
heroku ps:scale worker=1

Si usas webhooks, configura la URL del webhook en Heroku mediante la CLI o el panel de control. Asegúrate de que tu servidor tenga un certificado SSL válido, ya que Telegram requiere conexiones seguras para webhooks.

Mejoras y Personalización

Tu bot ahora es funcional, pero hay muchas formas de mejorarlo. Puedes agregar teclados personalizados para guiar las interacciones del usuario, implementar comandos inline para búsquedas rápidas, o integrar bases de datos como MongoDB para almacenar información del usuario. Por ejemplo, para agregar un teclado con opciones, modifica el código del comando /start:

from telegram import Update, ReplyKeyboardMarkup
from telegram.ext import Application, CommandHandler, ContextTypes

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        ["Clima", "Foto"],
        ["Ayuda"]
    ]
    reply_markup = ReplyKeyboardMarkup(keyboard, resize_keyboard=True)
    await update.message.reply_text("¡Hola! Elige una opción:", reply_markup=reply_markup)

def main():
    app = Application.builder().token("TU_TOKEN").build()

    app.add_handler(CommandHandler("start", start))

    app.run_polling()

if __name__ == "__main__":
    main()

Este código muestra un teclado con tres botones: “Clima”, “Foto” y “Ayuda”. Cuando el usuario selecciona una opción, el bot recibe el texto correspondiente, que puedes procesar con un MessageHandler. Este tipo de personalización mejora la experiencia del usuario y hace que el bot sea más intuitivo.

Otra mejora útil es programar tareas recurrentes, como enviar recordatorios diarios. Puedes usar la biblioteca schedule para ejecutar funciones en intervalos específicos:

pip install schedule

Luego, agrega una tarea que envíe un mensaje diario a un chat específico:

import schedule
import time
from telegram import Bot

def send_daily_message():
    bot = Bot(token="TU_TOKEN")
    chat_id = "TU_CHAT_ID"  # Reemplaza con el ID del chat
    bot.send_message(chat_id=chat_id, text="¡Buenos días! Recuerda revisar tus tareas.")

schedule.every().day.at("08:00").do(send_daily_message)

while True:
    schedule.run_pending()
    time.sleep(60)

Para obtener el chat_id, envía un mensaje al bot y usa la API de Telegram para recuperarlo: https://api.telegram.org/botTU_TOKEN/getUpdates. Este código enviará un mensaje diario a las 8:00 AM, lo que es ideal para bots de recordatorios o notificaciones.

Conclusiones

Crear un bot de Telegram con Python es un proyecto accesible que combina programación, automatización y tecnología de mensajería. A lo largo de este tutorial, hemos cubierto los pasos esenciales para desarrollar un bot funcional: desde registrarlo con BotFather hasta desplegarlo en un servidor. También hemos explorado cómo agregar funcionalidades avanzadas, como respuestas a mensajes, integración con APIs externas y manejo de errores, para crear una experiencia robusta y personalizada. Con las herramientas y técnicas presentadas, puedes adaptar tu bot a una amplia variedad de casos de uso, desde asistentes personales hasta herramientas de productividad para equipos. La clave para un bot exitoso es iterar sobre su diseño, escuchar retroalimentación de los usuarios y mantener el código actualizado con las últimas versiones de las bibliotecas. ¡Comienza a experimentar y lleva tus habilidades de programación al siguiente nivel con tu propio bot de Telegram!