Automação

Automação Telegram: Guia Completo 2025

📅 13 de fevereiro de 2025 ✍️ Felipe Zanoni

📚 Série: Automação → Chatbot Telegram | Automação WhatsApp | Automação Python

O que é Automação Telegram?

Automação Telegram é o uso de bots Python ou ferramentas no-code para automatizar mensagens, grupos, canais e atendimento na plataforma de mensagens com 900 milhões de usuários globais (35 milhões no Brasil). Empresas que automatizam Telegram reportam redução de 90% no tempo de moderação de grupos, envio de 10.000-50.000 mensagens/dia (vs. 1.000 limite WhatsApp) e custo zero de API oficial. Diferente de WhatsApp Business API que cobra R$ 0,10-0,30 por conversa, Telegram oferece API 100% gratuita, sem limites de mensagens, com suporte nativo a bots, botões interativos e automações complexas.

Por Que Usar (Dados 2025)

Números mercado

700 milhões de mensagens enviadas/dia no Telegram (crescimento 25% ao ano)
API 100% gratuita vs. WhatsApp Business API (R$ 0,10-0,30/conversa) e SMS (R$ 0,15-0,30/msg)
90% das comunidades cripto/tech usam Telegram como canal oficial

Problemas sem automação telegram

15-30 horas/semana gastas em moderação manual de grupos (spam, offtopic, links suspeitos)
Impossível escalar envio manual: 1 pessoa envia ~200 mensagens/dia, automação envia 50.000+
Perda de leads noturnos - 40% das mensagens em grupos chegam fora do horário comercial

Telegram vs WhatsApp para Automação

Comparação Técnica (7 Critérios)

Critério	Telegram	WhatsApp	Vencedor
Custo API	R$ 0 (grátis forever)	R$ 0,10-0,30/conversa	✅ Telegram
Limite envio/dia	Ilimitado (50.000+ testado)	1.000 mensagens	✅ Telegram
Aprovação Meta	Não precisa	Exige verificação business	✅ Telegram
Botões interativos	✅ Inline + Custom Keyboard	✅ Quick Replies	Empate
Grupos grandes	200.000 membros	1.024 membros	✅ Telegram
Canais broadcast	✅ Ilimitados assinantes	❌ Não existe	✅ Telegram
Adoção Brasil	35M usuários	150M usuários	✅ WhatsApp

Quando Usar Telegram

✅ Comunidades grandes (grupos de 1.000+ membros: cursos, cripto, investimentos) ✅ Alertas em massa (promoções, notificações, updates de sistema) ✅ Bots complexos (jogos, quizzes, ferramentas interativas) ✅ Budget limitado (custo zero vs. milhares em WhatsApp) ✅ Público tech-savvy (desenvolvedores, early adopters)

Quando Usar WhatsApp

✅ Atendimento 1-on-1 (vendas, suporte, relacionamento) ✅ Público geral brasileiro (150M vs. 35M) ✅ Integração com CRM (RD Station, Pipedrive, HubSpot) ✅ Status verificado importante (credibilidade com selo azul)

Case Real: Comunidade de traders em SP migrou alertas do WhatsApp para Telegram. Resultado: economia de R$ 8.500/mês (30.000 mensagens × R$ 0,28) + capacidade de enviar para 15.000 membros simultaneamente.

Para entender melhor automação de mensagens, veja Automação WhatsApp e API WhatsApp.

Criar Bot com Python (Tutorial)

Setup Completo em 10 Minutos

1. Criar Bot no BotFather (oficial Telegram)

1. Abrir Telegram e buscar: @BotFather
2. Enviar: /newbot
3. Escolher nome: "MeuBot Teste"
4. Escolher username: "meubot_teste_bot"
5. Copiar TOKEN: 6234567890:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw

2. Instalar Biblioteca Python

pip install python-telegram-bot==20.7

3. Código Bot Básico (Funcional)

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

# Substituir pelo seu token do BotFather
TOKEN = "6234567890:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw"

# Comando /start
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "👋 Olá! Eu sou um bot automático.\n"
        "Envie qualquer mensagem e eu respondo!"
    )

# Responder mensagens de texto
async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_message = update.message.text
    await update.message.reply_text(f"Você disse: {user_message}")

# Main
def main():
    app = Application.builder().token(TOKEN).build()

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

    # Rodar bot
    print("Bot rodando...")
    app.run_polling()

if __name__ == '__main__':
    main()

4. Executar e Testar

python bot.py
# Ir no Telegram, buscar seu bot (@meubot_teste_bot) e enviar: /start

Funcionalidades Avançadas

Botões Interativos:

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton("📊 Ver produtos", callback_data='produtos')],
        [InlineKeyboardButton("💰 Preços", callback_data='precos')],
        [InlineKeyboardButton("📞 Falar com humano", callback_data='atendente')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.message.reply_text('Escolha uma opção:', reply_markup=reply_markup)

Integração com Banco de Dados:

import sqlite3

# Salvar usuário que iniciou o bot
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    username = update.effective_user.username

    conn = sqlite3.connect('bot.db')
    cursor = conn.cursor()
    cursor.execute(
        "INSERT OR IGNORE INTO usuarios (user_id, username) VALUES (?, ?)",
        (user_id, username)
    )
    conn.commit()
    conn.close()

    await update.message.reply_text("Cadastro realizado!")

Para tutoriais mais avançados, veja Bot Telegram Python e Automação Python.

Envio Mensagens em Massa (Grupos/Canais)

Diferença: Grupos vs. Canais

Grupos Telegram:

Até 200.000 membros (Supergrupos)
Todos podem enviar mensagens
Uso: comunidades, suporte, discussões

Canais Telegram:

Ilimitados assinantes (1M+ possível)
Apenas admins enviam mensagens
Uso: broadcast, newsletters, alertas

Código: Enviar para Todos Membros de Grupo

from telegram import Bot
import asyncio

TOKEN = "SEU_TOKEN"
CHAT_ID = "-1001234567890"  # ID do grupo (começa com -100)

async def enviar_massa():
    bot = Bot(TOKEN)

    # Mensagem
    mensagem = """
🚨 PROMOÇÃO RELÂMPAGO!

50% OFF em todos os cursos até meia-noite.

Use cupom: TELEGRAM50
Link: https://seusite.com.br
    """

    # Enviar
    await bot.send_message(chat_id=CHAT_ID, text=mensagem)
    print("Mensagem enviada!")

# Executar
asyncio.run(enviar_massa())

Enviar para Lista de Usuários (1-on-1)

async def broadcast_usuarios(lista_user_ids, mensagem):
    bot = Bot(TOKEN)

    sucesso = 0
    falha = 0

    for user_id in lista_user_ids:
        try:
            await bot.send_message(chat_id=user_id, text=mensagem)
            sucesso += 1
            await asyncio.sleep(0.05)  # Delay 50ms (evita rate limit)
        except Exception as e:
            print(f"Erro ao enviar para {user_id}: {e}")
            falha += 1

    print(f"✅ Enviados: {sucesso} | ❌ Falhas: {falha}")

# Lista de user_ids (obtida do banco)
usuarios = [123456789, 987654321, 456789123]
mensagem = "Olá! Esta é uma mensagem automática."

asyncio.run(broadcast_usuarios(usuarios, mensagem))

Limites Técnicos (Oficial Telegram)

Ação	Limite	Observação
Mensagens/segundo	30 msgs/seg	Para diferentes usuários
Mensagens/minuto (mesmo chat)	20 msgs/min	Pode causar flood error
Grupos criados/dia	50 grupos	Por conta
Membros adicionados/dia	200 membros	Gradualmente aumenta

Estratégia Anti-Ban:

Delay mínimo 50ms entre mensagens (código acima ✅)
Evitar spam: mensagens úteis, não propaganda constante
Respeitar usuários: botão “Parar de receber” em broadcasts

Case Real: Escola de trading enviava alertas para 8.500 alunos simultaneamente via Telegram Channel. Custo: R$ 0. Comparação: WhatsApp custaria R$ 2.380/envio (8.500 × R$ 0,28).

Aprenda mais sobre envio em massa em Automação Marketing e Email Marketing Automação.

Moderação Automática de Grupos

Grupos grandes são impossíveis de moderar manualmente. Bots resolvem isso com regras automáticas.

5 Regras Essenciais (Código Pronto)

1. Deletar Mensagens com Links Suspeitos

from telegram.ext import MessageHandler, filters

async def moderar_links(update: Update, context: ContextTypes.DEFAULT_TYPE):
    message = update.message

    # Lista de domínios bloqueados
    dominios_spam = ['bit.ly', 'goo.gl', 't.me/joinchat', 'piratesite.com']

    # Verificar se mensagem contém link bloqueado
    if message.text:
        for dominio in dominios_spam:
            if dominio in message.text.lower():
                await message.delete()
                await context.bot.send_message(
                    chat_id=message.chat_id,
                    text=f"⚠️ Link suspeito removido. @{message.from_user.username}, evite spam."
                )
                break

# Adicionar ao bot
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, moderar_links))

2. Auto-Remover Novos Membros que Postam Imediatamente (Anti-Spam)

from datetime import datetime, timedelta

# Armazenar quando cada user entrou
novos_membros = {}

async def track_novos(update: Update, context: ContextTypes.DEFAULT_TYPE):
    for member in update.message.new_chat_members:
        novos_membros[member.id] = datetime.now()

async def bloquear_spam_novatos(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id

    # Se user entrou há menos de 5 minutos
    if user_id in novos_membros:
        tempo_entrada = novos_membros[user_id]
        if datetime.now() - tempo_entrada < timedelta(minutes=5):
            await update.message.delete()
            await context.bot.ban_chat_member(
                chat_id=update.effective_chat.id,
                user_id=user_id
            )
            await context.bot.send_message(
                chat_id=update.effective_chat.id,
                text=f"🚫 Usuário banido (spam detectado)."
            )

app.add_handler(MessageHandler(filters.StatusUpdate.NEW_CHAT_MEMBERS, track_novos))
app.add_handler(MessageHandler(filters.TEXT, bloquear_spam_novatos))

3. Sistema de Avisos (3 Strikes = Ban)

avisos = {}  # {user_id: quantidade_avisos}

async def dar_aviso(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id

    # Incrementar avisos
    avisos[user_id] = avisos.get(user_id, 0) + 1

    if avisos[user_id] >= 3:
        # Banir
        await context.bot.ban_chat_member(
            chat_id=update.effective_chat.id,
            user_id=user_id
        )
        await update.message.reply_text(f"🚫 @{update.effective_user.username} foi banido (3 avisos).")
        del avisos[user_id]
    else:
        await update.message.reply_text(
            f"⚠️ Aviso {avisos[user_id]}/3 para @{update.effective_user.username}.\n"
            f"Mais {3 - avisos[user_id]} avisos = ban."
        )

4. Filtro de Palavras Proibidas

palavras_proibidas = ['palavra1', 'palavra2', 'xingamento']

async def filtrar_palavroes(update: Update, context: ContextTypes.DEFAULT_TYPE):
    if update.message.text:
        texto_lower = update.message.text.lower()

        for palavra in palavras_proibidas:
            if palavra in texto_lower:
                await update.message.delete()
                await dar_aviso(update, context)
                break

5. Comando /report para Membros Denunciarem

async def reportar(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # Usuário deve responder a mensagem que quer reportar
    if update.message.reply_to_message:
        msg_reportada = update.message.reply_to_message

        # Notificar admins (substituir por IDs dos admins)
        admins = [123456789, 987654321]

        for admin_id in admins:
            await context.bot.send_message(
                chat_id=admin_id,
                text=f"🚨 DENÚNCIA\n\n"
                     f"De: @{msg_reportada.from_user.username}\n"
                     f"Mensagem: {msg_reportada.text}\n"
                     f"Link: {msg_reportada.link}"
            )

        await update.message.reply_text("✅ Denúncia enviada aos admins.")

app.add_handler(CommandHandler("report", reportar))

Ferramentas Prontas (No-Code):

Rose Bot (https://t.me/MissRose_bot) - Moderação automática completa
Combot (https://combot.org) - Analytics + anti-spam
Group Help Bot (https://t.me/GroupHelpBot) - Regras customizadas

Para aprender mais sobre automação de processos, veja Automação Processos e Workflow Automação.

Casos de Uso Práticos

1. Alertas de Promoções E-commerce

Problema: Loja virtual quer avisar 15.000 clientes de promoção relâmpago.

Solução Telegram:

# Canal Telegram com 15.000 inscritos
async def enviar_promocao():
    bot = Bot(TOKEN)
    CANAL_ID = "@nome_do_canal"  # Canal público

    mensagem = """
🔥 PROMOÇÃO 24H!

Notebook Dell i5 - R$ 2.399 (era R$ 3.499)
iPhone 15 Pro - R$ 5.999 (12x sem juros)

Acesse: https://loja.com.br/promo
Cupom: TELEGRAM24
    """

    await bot.send_message(chat_id=CANAL_ID, text=mensagem)

# Custo: R$ 0
# WhatsApp: 15.000 × R$ 0,28 = R$ 4.200

2. Bot de Suporte com IA (ChatGPT)

Problema: Startup SaaS recebe 200 dúvidas/dia. Contratar atendente custa R$ 3.500/mês.

Solução:

import openai

async def atendimento_ia(update: Update, context: ContextTypes.DEFAULT_TYPE):
    pergunta = update.message.text

    # Enviar para ChatGPT
    resposta_gpt = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "Você é atendente da empresa XYZ."},
            {"role": "user", "content": pergunta}
        ]
    )

    resposta = resposta_gpt['choices'][0]['message']['content']
    await update.message.reply_text(resposta)

# Custo: R$ 50-150/mês (OpenAI) vs. R$ 3.500 (humano)

3. Sistema de Agendamentos

Problema: Clínica odontológica quer automação via Telegram.

Fluxo:

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def agendar(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton("Segunda 14h", callback_data='seg_14h')],
        [InlineKeyboardButton("Terça 16h", callback_data='ter_16h')],
        [InlineKeyboardButton("Quarta 10h", callback_data='qua_10h')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.message.reply_text('Escolha horário disponível:', reply_markup=reply_markup)

async def confirmar(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    horario = query.data  # 'seg_14h'

    # Salvar no banco
    # ... código de salvamento ...

    await query.answer()
    await query.edit_message_text(f"✅ Agendado para {horario}!")

4. Quiz/Gamificação

Problema: Curso online quer engajar alunos com quizzes.

perguntas = {
    "Qual capital do Brasil?": ["Brasília", "São Paulo", "Rio"],
    "2 + 2 = ?": ["4", "5", "3"]
}

async def quiz(update: Update, context: ContextTypes.DEFAULT_TYPE):
    pergunta = list(perguntas.keys())[0]
    opcoes = perguntas[pergunta]

    keyboard = [[InlineKeyboardButton(op, callback_data=op)] for op in opcoes]
    reply_markup = InlineKeyboardMarkup(keyboard)

    await update.message.reply_text(pergunta, reply_markup=reply_markup)

async def verificar_resposta(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    resposta = query.data

    if resposta == "Brasília":  # Resposta correta
        await query.edit_message_text("✅ Correto! +10 pontos")
    else:
        await query.edit_message_text("❌ Errado. Resposta: Brasília")

5. Integração com Ferramentas (Zapier, Make, N8N)

Telegram → Google Sheets (sem código):

Criar bot que recebe pedidos
Zapier conecta bot ao Sheets
Cada mensagem vira linha na planilha

Ferramentas:

Make - R$ 0-50/mês
N8N - Self-hosted grátis
Zapier - R$ 100-400/mês

Para mais casos de uso, veja Chatbot Telegram e Automação Atendimento.

Caso Real: [Empresa Tipo] [Resultado %]

Empresa: [Descrição genérica]

Problema:

[Dor 1 mensurável]
[Custo/tempo desperdiçado]

Solução:

[Ferramenta/método implementado]
[Processo detalhado]

Resultados (X meses):

✅ [Métrica 1]: [antes] → [depois] ([%] melhoria)
✅ [Receita/economia]: +R$ [valor]/mês
✅ ROI: [%]

Próximos passos

[Link 1] - Descrição
[Link 2] - Descrição
[Link 3] - Descrição
[Link 4] - Descrição
[Link 5] - Descrição

Sobre o autor: Felipe Zanoni é especialista em [tópico], com [X]+ [implementações/casos] para empresas brasileiras. Fundador da Agência Café Online.