Cómo hacer un bot de Telegram con Python paso a paso: un proyecto chico para tu portfolio que muestra APIs y automatización

Resumen ejecutivo

• Un bot de Telegram en Python es un proyecto ideal para tu portfolio: es corto, se puede probar desde el celular y muestra que sabés consumir una API y manejar eventos.

• Vas a crear el bot con BotFather, programarlo con la librería python-telegram-bot y sumarle un comando que consulta datos reales de una API pública.

• El token del bot es como una contraseña: guardalo en una variable de entorno y nunca lo subas a GitHub.

• Al final te dejamos ideas para ampliarlo y una guía para presentarlo en GitHub de forma que sume en una entrevista.

Cuando estás aprendiendo Python, llega un momento en que los ejercicios de consola ya no alcanzan y necesitás un proyecto que alguien más pueda usar. Un bot de Telegram cumple justo esa función: en una tarde tenés algo funcionando, se lo podés mandar a un reclutador para que lo pruebe y demuestra habilidades que se usan en trabajos reales, como integrar APIs, manejar errores y proteger credenciales. En este tutorial vas a construir un bot que responde comandos y consulta la cotización del dólar en tiempo real.

Qué necesitás antes de empezar

• Python instalado en tu computadora (versión 3.9 o superior).

• Una cuenta de Telegram.

• Saber lo básico de Python: funciones, diccionarios y cómo instalar paquetes con pip.

Paso 1: crear el bot con BotFather

En Telegram, los bots se crean desde otro bot oficial llamado @BotFather. Según el tutorial oficial de Telegram, el proceso es:

1. Buscá @BotFather en Telegram y abrí el chat.

2. Enviá el comando /newbot.

3. Elegí un nombre visible y un usuario que termine en «bot» (por ejemplo, cotizaciones_demo_bot).

4. BotFather te devuelve un token. Copialo y guardalo en un lugar seguro.

Ese token le da control total sobre tu bot a quien lo tenga. No lo compartas ni lo pegues en tu código.

Paso 2: preparar el proyecto

mkdir bot-telegram
cd bot-telegram
python -m venv venv
source venv/bin/activate   # en Windows: venv\Scripts\activate
pip install python-telegram-bot requests

mkdir bot-telegram
cd bot-telegram
python -m venv venv
source venv/bin/activate   # en Windows: venv\Scripts\activate
pip install python-telegram-bot requests

mkdir bot-telegram
cd bot-telegram
python -m venv venv
source venv/bin/activate   # en Windows: venv\Scripts\activate
pip install python-telegram-bot requests

mkdir bot-telegram
cd bot-telegram
python -m venv venv
source venv/bin/activate   # en Windows: venv\Scripts\activate
pip install python-telegram-bot requests

Usamos python-telegram-bot, una de las librerías más usadas y mejor documentadas, y requests para consultar APIs externas.

Ahora guardá el token como variable de entorno (en Windows, con set en lugar de export):

export TELEGRAM_TOKEN="pegá-acá-tu-token"

export TELEGRAM_TOKEN="pegá-acá-tu-token"

export TELEGRAM_TOKEN="pegá-acá-tu-token"

export TELEGRAM_TOKEN="pegá-acá-tu-token"

Paso 3: un bot que responde /start

Creá un archivo bot.py:

import os
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

TOKEN = os.environ["TELEGRAM_TOKEN"]

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "¡Hola! Soy un bot de cotizaciones. Probá /dolar o /ayuda."
    )

async def ayuda(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "/dolar: cotización del dólar blue\n/ayuda: lista de comandos"
    )

app = ApplicationBuilder().token(TOKEN).build()
app.add_handler(CommandHandler("start", start))
app.add_handler(CommandHandler("ayuda", ayuda))
app.run_polling()

import os
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

TOKEN = os.environ["TELEGRAM_TOKEN"]

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "¡Hola! Soy un bot de cotizaciones. Probá /dolar o /ayuda."
    )

async def ayuda(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "/dolar: cotización del dólar blue\n/ayuda: lista de comandos"
    )

app = ApplicationBuilder().token(TOKEN).build()
app.add_handler(CommandHandler("start", start))
app.add_handler(CommandHandler("ayuda", ayuda))
app.run_polling()

import os
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

TOKEN = os.environ["TELEGRAM_TOKEN"]

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "¡Hola! Soy un bot de cotizaciones. Probá /dolar o /ayuda."
    )

async def ayuda(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "/dolar: cotización del dólar blue\n/ayuda: lista de comandos"
    )

app = ApplicationBuilder().token(TOKEN).build()
app.add_handler(CommandHandler("start", start))
app.add_handler(CommandHandler("ayuda", ayuda))
app.run_polling()

import os
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

TOKEN = os.environ["TELEGRAM_TOKEN"]

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "¡Hola! Soy un bot de cotizaciones. Probá /dolar o /ayuda."
    )

async def ayuda(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "/dolar: cotización del dólar blue\n/ayuda: lista de comandos"
    )

app = ApplicationBuilder().token(TOKEN).build()
app.add_handler(CommandHandler("start", start))
app.add_handler(CommandHandler("ayuda", ayuda))
app.run_polling()

Ejecutá python bot.py, buscá tu bot en Telegram y mandale /start. Si te responde, ya tenés un bot funcionando. El método run_polling hace que tu programa le pregunte a Telegram cada pocos segundos si hay mensajes nuevos.

Paso 4: sumar un comando que consulta una API

Ahora lo interesante: un comando que trae datos reales. Usamos DolarApi, una API pública y gratuita con cotizaciones en Argentina. Agregá esta función antes de crear app:

import requests

async def dolar(update: Update, context: ContextTypes.DEFAULT_TYPE):
    try:
        r = requests.get("https://dolarapi.com/v1/dolares/blue", timeout=10)
        r.raise_for_status()
        datos = r.json()
        texto = (
            f"Dólar blue\n"
            f"Compra: ${datos['compra']}\n"
            f"Venta: ${datos['venta']}"
        )
    except requests.RequestException:
        texto = "No pude consultar la cotización. Probá de nuevo en un rato."
    await update.message.reply_text(texto)

import requests

async def dolar(update: Update, context: ContextTypes.DEFAULT_TYPE):
    try:
        r = requests.get("https://dolarapi.com/v1/dolares/blue", timeout=10)
        r.raise_for_status()
        datos = r.json()
        texto = (
            f"Dólar blue\n"
            f"Compra: ${datos['compra']}\n"
            f"Venta: ${datos['venta']}"
        )
    except requests.RequestException:
        texto = "No pude consultar la cotización. Probá de nuevo en un rato."
    await update.message.reply_text(texto)

import requests

async def dolar(update: Update, context: ContextTypes.DEFAULT_TYPE):
    try:
        r = requests.get("https://dolarapi.com/v1/dolares/blue", timeout=10)
        r.raise_for_status()
        datos = r.json()
        texto = (
            f"Dólar blue\n"
            f"Compra: ${datos['compra']}\n"
            f"Venta: ${datos['venta']}"
        )
    except requests.RequestException:
        texto = "No pude consultar la cotización. Probá de nuevo en un rato."
    await update.message.reply_text(texto)

import requests

async def dolar(update: Update, context: ContextTypes.DEFAULT_TYPE):
    try:
        r = requests.get("https://dolarapi.com/v1/dolares/blue", timeout=10)
        r.raise_for_status()
        datos = r.json()
        texto = (
            f"Dólar blue\n"
            f"Compra: ${datos['compra']}\n"
            f"Venta: ${datos['venta']}"
        )
    except requests.RequestException:
        texto = "No pude consultar la cotización. Probá de nuevo en un rato."
    await update.message.reply_text(texto)

Y registralo junto con los otros comandos:

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

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

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

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

Fijate en el try/except: si la API no responde, el bot avisa en lugar de romperse. Este detalle es exactamente el tipo de cosa que un entrevistador mira en tu código. Si estás en otro país, podés cambiar la fuente por otra API, como OpenWeatherMap para el clima, que requiere registrarte para obtener una clave gratuita.

Paso 5: responder mensajes de texto libre

Para que el bot reaccione a cualquier mensaje, no solo a comandos, sumá un MessageHandler:

from telegram.ext import MessageHandler, filters

async def eco(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "No entendí. Escribí /ayuda para ver lo que sé hacer."
    )

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

from telegram.ext import MessageHandler, filters

async def eco(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "No entendí. Escribí /ayuda para ver lo que sé hacer."
    )

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

from telegram.ext import MessageHandler, filters

async def eco(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "No entendí. Escribí /ayuda para ver lo que sé hacer."
    )

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

from telegram.ext import MessageHandler, filters

async def eco(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "No entendí. Escribí /ayuda para ver lo que sé hacer."
    )

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

La documentación de funciones de bots de Telegram muestra todo lo que podés agregar después: botones, menús de comandos, envío de imágenes y más. Y si querés ir a bajo nivel, la referencia de la Bot API lista cada método disponible.

Paso 6: ponerlo en línea

Mientras tu computadora esté apagada, el bot no responde. Para que funcione siempre, tenés que ejecutarlo en un servidor. Hay servicios de hosting con planes gratuitos o de bajo costo que permiten correr scripts de Python; configurás la variable de entorno con el token en el panel del servicio, nunca en el código.

Ideas para ampliarlo

• Un comando /alerta que avise cuando la cotización supera un valor.

• Guardar las consultas de cada usuario en una base de datos SQLite.

• Botones en línea para elegir entre distintos tipos de cotización.

• Combinarlo con web scraping para traer datos de un sitio que no tiene API (mirá cómo hacer web scraping con Python).

• Tests automáticos para las funciones que procesan datos.

Cómo presentarlo en tu portfolio

• README claro: qué hace el bot, una captura o GIF de la conversación, cómo instalarlo y la lista de comandos.

• Archivo de ejemplo de configuración: un .env.example con el nombre de la variable, sin el token real, y un .gitignore que excluya el .env.

• Link al bot: si está en línea, poné el usuario para que lo prueben.

• Qué aprendiste: dos o tres líneas sobre decisiones técnicas, como el manejo de errores de la API.

Si todavía no tenés claro qué es una API, repasá API REST explicadas para no técnicos.

Curso recomendado de Coderhouse

Si querés afianzar las bases para este y otros proyectos, el curso de Python te enseña a programar scripts, trabajar con estructuras de datos y aplicar programación orientada a objetos, con práctica constante.

Preguntas frecuentes

¿Crear un bot de Telegram es gratis? Sí. Crear el bot con BotFather y usar la Bot API no tiene costo. Lo único que puede costar es el servidor para tenerlo siempre en línea.

¿Qué pasa si subo el token a GitHub por error? Cualquiera podría controlar tu bot. Revocalo de inmediato desde BotFather con /revoke, generá uno nuevo y borralo del historial del repositorio.

¿Polling o webhook? Para aprender y proyectos chicos, polling es más simple. Los webhooks son más eficientes en producción, pero requieren un servidor con dirección pública y HTTPS.

¿Un bot de Telegram sirve como proyecto para conseguir trabajo? Sí, sobre todo si está bien documentado, maneja errores y consume una API real. Mostralo junto con uno o dos proyectos más de otro tipo.