Tutorial bot Telegram Python: Aprende paso a paso a crear tu bot desde cero

Si eres desarrollador principiante o intermedio y quieres aprender cómo crear un bot para Telegram usando Python, estás en el lugar indicado. En este tutorial bot Telegram Python te llevaré de la mano para que configures tu entorno, registres tu bot con BotFather, uses la API de Telegram para enviar y recibir mensajes, implementes comandos básicos y finalmente despliegues tu bot de forma sencilla. ¡Vamos allá!

¿Qué es un bot de Telegram y por qué usar Python?

Un bot de Telegram es un programa que puede interactuar con usuarios a través de chats, enviar respuestas automáticas, procesar comandos, y ofrecer funcionalidades variadas. Python es uno de los lenguajes más populares para el desarrollo bots Python, gracias a su sencillez y librerías especializadas como python-telegram-bot.

1. Configuración del entorno para crear bot Telegram

a) Requisitos previos

Tener Python instalado (recomendado 3.7 o superior)
Editor de código (VSCode, PyCharm, etc.)
Acceso a Telegram y una cuenta activa

b) Crear un entorno virtual (opcional pero recomendable)

python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

python -m venv venv

source venv/bin/activate # Linux/Mac

venv\Scripts\activate # Windows

c) Instalar la librería necesaria

La más utilizada es python-telegram-bot. Instálala usando pip:

pip install python-telegram-bot --upgrade

1 2	pip install python-telegram-bot --upgrade

2. Registro del bot con BotFather

Para crear un bot debes registrarlo en Telegram con BotFather, el bot oficial para gestionar nuevos bots.

Pasos:

Abre Telegram y busca el usuario @BotFather.
Inicia un chat y escribe /newbot.
Sigue las instrucciones para darle un nombre y un username único terminado en “bot”.
Una vez creado, BotFather te enviará un token que usarás para conectar tu código.

Importante: Guarda ese token con cuidado, es la clave para usar la API Telegram Python.

3. Primer bot: Código básico para recibir y enviar mensajes

Vamos a crear un bot simple que responda “Hola, mundo!” cuando recibe el comando /start.

from telegram import Update
from telegram.ext import Updater, CommandHandler, CallbackContext

# Reemplaza aquí con tu token
TOKEN = 'TU_TOKEN_AQUI'

# Función para manejar el comando /start
 def start(update: Update, context: CallbackContext) -> None:
     update.message.reply_text('Hola, mundo! Soy tu bot de Telegram 😀')


def main():
    updater = Updater(TOKEN)

    dispatcher = updater.dispatcher

    # Registramos manejador para el comando /start
    dispatcher.add_handler(CommandHandler('start', start))

    # Empezamos a escuchar mensajes
    updater.start_polling()
    print("Bot activo. Ctrl+C para parar.")

    # Mantiene el bot corriendo hasta que se interrumpe
    updater.idle()


if __name__ == '__main__':
    main()

from telegram import Update

from telegram.ext import Updater, CommandHandler, CallbackContext

# Reemplaza aquí con tu token

TOKEN = 'TU_TOKEN_AQUI'

# Función para manejar el comando /start

def start(update: Update, context: CallbackContext) -> None:

update.message.reply_text('Hola, mundo! Soy tu bot de Telegram 😀')

def main():

updater = Updater(TOKEN)

dispatcher = updater.dispatcher

# Registramos manejador para el comando /start

dispatcher.add_handler(CommandHandler('start', start))

# Empezamos a escuchar mensajes

updater.start_polling()

print("Bot activo. Ctrl+C para parar.")

# Mantiene el bot corriendo hasta que se interrumpe

updater.idle()

if __name__ == '__main__':

main()

Cómo probarlo

Guarda el script como bot.py.
Ejecuta python bot.py.
Abre Telegram, busca tu bot por username y envía /start.
Deberías recibir la respuesta “Hola, mundo! Soy tu bot de Telegram 😀”.

4. Manejo de comandos básicos y respuestas

Puedes ampliar el bot agregando más comandos y lógica sencilla.

from telegram.ext import MessageHandler, Filters

# Comando /help
 def help_command(update: Update, context: CallbackContext) -> None:
     update.message.reply_text('Estos son los comandos disponibles:\n/start - Inicia el bot\n/help - Muestra esta ayuda\n/saludo - Te saluda')

# Comando /saludo
 def saludo(update: Update, context: CallbackContext) -> None:
     user_first_name = update.effective_user.first_name
     update.message.reply_text(f'¡Hola, {user_first_name}! ¿Cómo estás?')

# Responder a mensajes de texto que no son comandos
 def echo(update: Update, context: CallbackContext) -> None:
     text = update.message.text
     update.message.reply_text(f'Dijiste: {text}')


def main():
    updater = Updater(TOKEN)
    dispatcher = updater.dispatcher

    dispatcher.add_handler(CommandHandler('start', start))
    dispatcher.add_handler(CommandHandler('help', help_command))
    dispatcher.add_handler(CommandHandler('saludo', saludo))
    dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command, echo))

    updater.start_polling()
    print("Bot ejecutándose...")
    updater.idle()

if __name__ == '__main__':
    main()

from telegram.ext import MessageHandler, Filters

# Comando /help

def help_command(update: Update, context: CallbackContext) -> None:

update.message.reply_text('Estos son los comandos disponibles:\n/start - Inicia el bot\n/help - Muestra esta ayuda\n/saludo - Te saluda')

# Comando /saludo

def saludo(update: Update, context: CallbackContext) -> None:

user_first_name = update.effective_user.first_name

update.message.reply_text(f'¡Hola, {user_first_name}! ¿Cómo estás?')

# Responder a mensajes de texto que no son comandos

def echo(update: Update, context: CallbackContext) -> None:

text = update.message.text

update.message.reply_text(f'Dijiste: {text}')

def main():

updater = Updater(TOKEN)

dispatcher = updater.dispatcher

dispatcher.add_handler(CommandHandler('start', start))

dispatcher.add_handler(CommandHandler('help', help_command))

dispatcher.add_handler(CommandHandler('saludo', saludo))

dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command, echo))

updater.start_polling()

print("Bot ejecutándose...")

updater.idle()

if __name__ == '__main__':

main()

Con este código, el bot responde a:

/help mostrando los comandos
/saludo con un mensaje personalizado
Cualquier texto por fuera de comandos con un “echo” de lo que escribiste

5. Manejo de actualizaciones: Long Polling vs Webhooks

Long Polling (lo que usamos hasta ahora)

El bot pregunta periódicamente a Telegram si hay nuevos mensajes.
Fácil de implementar y suficiente para bots pequeños.

Webhooks

Telegram envía las actualizaciones directamente a una URL de tu servidor.
Requiere un servidor con HTTPS público.
Más eficiente para bots con mucho tráfico.

Ejemplo simple de webhook (avanzado, requiere servidor y HTTPS):

from telegram.ext import Updater, Dispatcher, CommandHandler
from flask import Flask, request

app = Flask(__name__)

TOKEN = 'TU_TOKEN'

updater = Updater(TOKEN, use_context=True)
dispatcher = updater.dispatcher

def start(update, context):
    update.message.reply_text('¡Hola desde webhook!')

dispatcher.add_handler(CommandHandler('start', start))

@app.route(f'/{TOKEN}', methods=['POST'])
def webhook():
    update = Update.de_json(request.get_json(force=True), updater.bot)
    dispatcher.process_update(update)
    return 'OK'

if __name__ == '__main__':
    # Configurar webhook previamente con Telegram
    # updater.start_webhook(listen='0.0.0.0', port=443, url_path=TOKEN,
    #                      webhook_url='https://tu-dominio.com/' + TOKEN)
    app.run(port=8443)

from telegram.ext import Updater, Dispatcher, CommandHandler

from flask import Flask, request

app = Flask(__name__)

TOKEN = 'TU_TOKEN'

updater = Updater(TOKEN, use_context=True)

dispatcher = updater.dispatcher

def start(update, context):

update.message.reply_text('¡Hola desde webhook!')

dispatcher.add_handler(CommandHandler('start', start))

@app.route(f'/{TOKEN}', methods=['POST'])

def webhook():

update = Update.de_json(request.get_json(force=True), updater.bot)

dispatcher.process_update(update)

return 'OK'

if __name__ == '__main__':

# Configurar webhook previamente con Telegram

# updater.start_webhook(listen='0.0.0.0', port=443, url_path=TOKEN,

# webhook_url='https://tu-dominio.com/' + TOKEN)

app.run(port=8443)

Para la mayoría de principiantes es recomendable empezar con long polling.

6. Despliegue sencillo del bot

Una vez tu bot esté listo, puedes desplegarlo en un servidor para que esté siempre activo. Algunas opciones gratuitas o económicas son:

Heroku: Popular para principiantes, gratuito con limitaciones.
PythonAnywhere: Hosting Python sencillo.
VPS (DigitalOcean, AWS, etc.): Para control total.

Desplegar en Heroku (resumen rápido)

Crea un archivo requirements.txt con:

python-telegram-bot
Flask

python-telegram-bot

Flask

(si usas webhook)

Crea un Procfile con:

worker: python bot.py

1 2	worker: python bot.py

Inicializa git, sube a Heroku y configura las variables de entorno (TOKEN).
Ejecuta el bot con el comando heroku ps:scale worker=1.

Consulta la documentación de Heroku para más detalle

Buenas prácticas para desarrollo bots Python Telegram

Nunca compartas tu token públicamente.
Maneja excepciones para evitar que el bot crashee.
Usa variables de entorno para datos sensibles.
Realiza pruebas en un chat privado o grupo de prueba.
Documenta tu código para facilitar mantenimiento.
Actualiza la librería regularmente.

Conclusión

¡Felicidades! Ahora sabes cómo crear un bot Telegram usando Python desde cero: configuraste el entorno, registraste el bot, programaste sus comandos básicos, entendiste la diferencia entre polling y webhooks y aprendiste ideas para desplegarlo en producción.

No dudes en experimentar creando comandos más sofisticados, integrando APIs externas o agregando automatizaciones que hagan tu bot único.

¿Qué esperas? ¡Empieza a crear tu bot ahora mismo! Comparte este tutorial con amigos desarrolladores y comentar abajo qué proyecto de bot te gustaría construir.