Como ser avisado quando alguém postar no Twitter

#Ative as notificações dos posts de alguém

O alerta do próprio X é o sino em cada perfil, e leva quatro passos no app do X no iPhone ou no Android. Os nomes abaixo são os que a Central de Ajuda do X usa hoje.

1. Siga a conta. O sino só aparece em perfis que você segue.

2. Toque no sino no perfil dela. Ele fica ao lado do botão Seguindo.

3. Escolha Todos os posts. A outra opção, Somente posts com vídeo ao vivo, avisa apenas quando a conta entra ao vivo.

4. Confira se o push está ativo. Toque na foto do seu perfil, depois em Configurações e privacidade, Notificações, Preferências e Notificações push, e mantenha posts ativado. As configurações do próprio celular também precisam permitir que o app do X envie notificações.

Para parar os alertas, toque no sino de novo e escolha Nenhum. Para ver todas as contas de que você recebe alertas de posts, abra a mesma tela de Notificações push e toque em posts. A Central de Ajuda do X (abre em uma nova aba) lista os outros tipos de notificação: menções, respostas, reposts, curtidas, novos seguidores e mensagens.

#O que o sino não faz

O sino é um alerta pessoal no celular. Ele deixa de bastar assim que você precisa de mais do que os posts de uma pessoa em um celular:

• Você precisa seguir a conta. Sem seguir, sem sino, então a conta de um concorrente ou o feed de um órgão regulador que você prefere não seguir fica em silêncio.
• Um perfil por vez. Acompanhar 300 contas significa 300 sinos ligados à mão.
• Só os seus dispositivos ouvem. O alerta vai para os celulares logados na sua conta do X. Um grupo do Telegram, um canal do Slack, um bot de trading ou um colega nunca o vê.
• Sem palavras, só pessoas. O sino não tem opção de palavra-chave: ele não consegue esperar por uma cashtag, o nome de um produto ou por alguém dizer "launch".

Serviços de automação no-code cobrem parte da lacuna, mas eles também verificam o X em um intervalo fixo, de poucos em poucos minutos nos planos pagos a uma vez por hora em alguns gratuitos, e alguns pedem que você conecte a sua própria conta do X. Um script pequeno que você mesmo roda resolve os quatro limites: quaisquer contas públicas, palavras ou ambos, verificados com a frequência que você escolher e entregues em qualquer chat.

#Receba alertas de muitas contas com uma Lista do X

Para receber alertas de muitas contas de uma vez, coloque-as em uma Lista pública do X e leia o feed da Lista em um intervalo fixo: uma requisição devolve os posts mais recentes de até 5.000 contas. Uma Lista do X é um grupo nomeado de contas no x.com. Você não precisa seguir ninguém que adicionar, qualquer Lista pública mantida por outra pessoa também serve, e o feed da Lista mostra os posts dos membros do mais recente para o mais antigo.

Todo post no X tem um ID numérico que cresce com o tempo. O seu script guarda o maior ID que já enviou como ponto de controle; a cada verificação, tudo acima desse número é novo e vira um alerta. Verificando a cada minuto, nenhum post espera mais de um minuto.

Para alertas de tweets de muitas contas do X, use a Sorsa API, uma API e scraper do Twitter (X): o GET /list-tweets (abre em uma nova aba) lê os posts mais recentes de uma Lista inteira de até 5.000 contas em uma requisição, todo plano roda 20 requisições por segundo, e uma verificação custa o mesmo se a Lista postou uma vez ou vinte. Cada post chega com o perfil completo do autor, atrás de um único header ApiKey em vez de uma conta de desenvolvedor.

Lado a lado com o sino:

• Contas por alerta

  Sorsa API com uma Lista do X

  Até 5.000 em uma requisição

  Sino do X

  Um sino por perfil

• Precisa seguir

  Sorsa API com uma Lista do X

  Não

  Sino do X

  Sim

• Para onde vão os alertas

  Sorsa API com uma Lista do X

  Telegram, Slack, e-mail, um banco de dados

  Sino do X

  O app do X nos seus dispositivos

• Alertas por palavra-chave

  Sorsa API com uma Lista do X

  Sim, com operadores de busca do X

  Sino do X

  Não

• Com que frequência verifica

  Sorsa API com uma Lista do X

  Você escolhe, até de segundos em segundos

  Sino do X

  Definida pelo X

• Seu login no X

  Sorsa API com uma Lista do X

  Nunca é pedido

  Sino do X

  Obrigatório

O guia de monitoramento do Twitter em tempo real aplica a mesma ideia com um intervalo de 5 segundos em várias Listas e feeds de palavras-chave. Criar uma Lista em massa e exportar seus membros está no guia da API de Listas do Twitter.

#Envie os posts novos para o Telegram ou o Slack

Um script Python de cerca de 80 linhas verifica a Lista a cada minuto e envia cada lote de posts novos para um chat do Telegram, um canal do Slack ou ambos. Seis passos o colocam para rodar.

1. Obtenha uma chave. Crie sua conta e copie a chave de API no seu painel. As 100 requisições grátis já estão nela.

2. Crie a Lista. No x.com, abra Listas, crie uma nova Lista, deixe Privada desmarcada e adicione as contas. O ID da Lista é o número longo no fim do endereço dela, depois de /i/lists/.

3. Prepare o lado do chat. No Slack, crie um app, ative os Incoming Webhooks, adicione um webhook para o seu canal e copie a URL dele. No Telegram, mande uma mensagem para o BotFather, envie /newbot e copie o token do bot. Adicione o bot ao seu grupo, publique qualquer mensagem lá, depois abra este endereço em um navegador e copie o ID do chat que vem depois de "chat":{"id":.

   https://api.telegram.org/bot<token>/getUpdates
   

4. Verifique a Lista uma vez. Esta requisição devolve a página mais recente do feed da Lista, com até 20 posts e seus autores.

   curl -G "https://api.sorsa.io/v3/list-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "list_id=1851937264019283746"
   

   {
     "tweets": [
       {
         "id": "2117204918263512064",
         "full_text": "Mainnet upgrade is live. Bridges reopen at 14:00 UTC.",
         "created_at": "2026-11-02T13:12:40Z",
         "lang": "en",
         "is_reply": false,
         "likes_count": 41,
         "retweet_count": 12,
         "reply_count": 6,
         "view_count": 3870,
         "user": {
           "id": "1658112940377133056",
           "username": "northwind_protocol_hq",
           "display_name": "Northwind Protocol",
           "followers_count": 64120,
           "verified": true
         }
       },
       {
         "id": "2117204657719308288",
         "full_text": "Our Q4 roadmap call starts in 30 minutes.",
         "created_at": "2026-11-02T13:11:38Z",
         "lang": "en",
         "is_reply": false,
         "likes_count": 9,
         "retweet_count": 2,
         "reply_count": 1,
         "view_count": 1104,
         "user": {
           "id": "1702291101836602498",
           "username": "lumenforge_labs_team",
           "display_name": "Lumenforge Labs",
           "followers_count": 18832,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAABCgABG3kRk8f__-oKAAIbeRGT0_7_6ggAAwAAAAIAAA"
   }
   

   Ver resposta completa

5. Rode o script de alertas. Salve-o como x_alerts.py. A primeira execução apenas registra o ID mais recente, para você não ser inundado de posts antigos; cada verificação seguinte envia o que é novo.

   import os
   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": os.environ.get("SORSA_API_KEY", "YOUR_API_KEY")}
   LIST_ID = os.environ["X_LIST_ID"]
   TG_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN")
   TG_CHAT = os.environ.get("TELEGRAM_CHAT_ID")
   SLACK_URL = os.environ.get("SLACK_WEBHOOK_URL")
   INTERVAL = 60          # seconds between checks
   STATE = "last_id.txt"  # the checkpoint survives restarts
   ORIGINALS_ONLY = True  # skip replies and reposts
   
   
   def new_posts(last_id):
       """Read the List's feed back to the checkpoint, oldest first."""
       posts, params = [], {"list_id": LIST_ID}
       for _ in range(5):  # at most 5 pages per check
           r = requests.get(f"{API}/list-tweets", headers=HEADERS,
                            params=params, timeout=30)
           r.raise_for_status()
           page = r.json()
           tweets = page.get("tweets") or []
           fresh = [t for t in tweets if int(t["id"]) > last_id]
           posts += fresh
           cursor = page.get("next_cursor")
           if not last_id or len(fresh) < len(tweets) or not cursor:
               break
           params["next_cursor"] = cursor
       return sorted(posts, key=lambda t: int(t["id"]))
   
   
   def line(t):
       user = t["user"]["username"]
       link = f"https://x.com/{user}/status/{t['id']}"
       return f"@{user}: {t['full_text'][:300]}\n{link}"
   
   
   def messages(lines, limit=4000):
       """Pack posts into as few chat messages as fit."""
       msg = ""
       for ln in lines:
           if msg and len(msg) + len(ln) + 2 > limit:
               yield msg
               msg = ""
           msg = f"{msg}\n\n{ln}" if msg else ln
       if msg:
           yield msg
   
   
   def send(text):
       if TG_TOKEN:
           url = f"https://api.telegram.org/bot{TG_TOKEN}/sendMessage"
           requests.post(url, json={"chat_id": TG_CHAT, "text": text},
                         timeout=30)
       if SLACK_URL:
           requests.post(SLACK_URL, json={"text": text}, timeout=30)
       time.sleep(1.1)  # both chats take about one message a second
   
   
   try:
       last_id = int(open(STATE).read())
   except (OSError, ValueError):
       last_id = 0
   
   while True:
       try:
           posts = new_posts(last_id)
           keep = [t for t in posts if not ORIGINALS_ONLY or not (
               t.get("is_reply") or t.get("retweeted_status"))]
           if last_id and keep:  # the first run only sets the checkpoint
               for text in messages([line(t) for t in keep]):
                   send(text)
           if posts:
               last_id = int(posts[-1]["id"])
               with open(STATE, "w") as f:
                   f.write(str(last_id))
       except requests.RequestException as err:
           print("check failed, retrying next round:", err)
       time.sleep(INTERVAL)
   

6. Deixe-o rodando. Coloque as chaves em variáveis de ambiente e inicie o script em qualquer máquina que fique ligada: um servidor pequeno, um contêiner ou um computador sobrando. Tire as linhas do Telegram ou do Slack se você usar só um chat.

   export SORSA_API_KEY="YOUR_API_KEY"
   export X_LIST_ID="1851937264019283746"
   export TELEGRAM_BOT_TOKEN="123456789:YOUR_BOT_TOKEN"
   export TELEGRAM_CHAT_ID="-1001234567890"
   export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
   nohup python3 x_alerts.py > x_alerts.log 2>&1 &
   

Cada alerta traz o @ do autor, o texto e um link para o post, então um toque o abre no X. Quando vários membros postam entre duas verificações, os posts chegam agrupados em uma única mensagem.

O script respeita os limites de cada chat. O FAQ de bots do Telegram (abre em uma nova aba) pede que os bots enviem no máximo uma mensagem por segundo para um chat e 20 por minuto para um grupo, e uma mensagem comporta até 4.096 caracteres. Os limites de taxa do Slack (abre em uma nova aba) permitem a um webhook de entrada uma mensagem por segundo e respondem a um excesso contínuo com um erro HTTP 429. Agrupar os posts em mensagens de até 4.000 caracteres e esperar um segundo entre elas mantém os dois canais tranquilos e completos.

#Com que rapidez o alerta chega e quanto custa

Um alerta chega dentro de um intervalo de verificação depois do post, e a conta mensal segue o intervalo, não o número de posts: a Sorsa API conta uma requisição por verificação, ache ela vinte posts novos ou nenhum. Em um mês de 30 dias, uma Lista verificada a cada minuto usa 43,2 mil requisições, que as 100 mil do plano Pro cobrem duas vezes:

• 5 minutos

  Requisições por mês, uma Lista

  8,6 mil

  Plano que cobre

  Starter, 10 mil por mês

• 1 minuto

  Requisições por mês, uma Lista

  43,2 mil

  Plano que cobre

  Pro, 100 mil por mês

• 30 segundos

  Requisições por mês, uma Lista

  86,4 mil

  Plano que cobre

  Pro, 100 mil por mês

• 15 segundos

  Requisições por mês, uma Lista

  173 mil

  Plano que cobre

  Growth, 250 mil por mês

Uma Lista é um único feed, seja qual for o tamanho dela, então vigiar 5.000 contas custa o mesmo que vigiar cinco. Mais de 5.000 contas significa mais uma Lista e mais uma requisição por verificação. O construtor abaixo calcula os feeds, as requisições e o plano para a sua lista de monitoramento.

A API oficial do X cobra do outro jeito, por post entregue. Os preços de pagamento por uso (abre em uma nova aba) dela cobram US$ 0,005 por cada post que o stream ou a busca devolve, US$ 5,00 por 1.000, até 3 milhões de posts lidos por mês, depois de uma conta de desenvolvedor aprovada e da configuração de um app OAuth. A partir de 22 de novembro de 2026, o X também cobra o autor devolvido com cada post como uma leitura de usuário a US$ 0,010, segundo o aviso do X de 23 de outubro (abre em uma nova aba), então um post com o autor custa US$ 0,015. Uma lista de monitoramento de 5.000 contas que postam três vezes por dia cada uma envia 450 mil posts por mês: US$ 2.250 na tarifa atual e US$ 6.750 com os autores. Na Sorsa API, a mesma Lista verificada a cada minuto fica no plano Pro, a US$ 199 por mês.

Requisições que falham nunca são cobradas, e o GET /key-usage-info (abre em uma nova aba) mostra as requisições que restam na sua chave sem gastar nenhuma.

#Alertas para uma conta, uma palavra-chave ou uma menção

Troque a requisição dentro de new_posts() e o mesmo script alerta sobre uma conta, sobre palavras dos membros da sua Lista ou sobre palavras de qualquer pessoa no X. Cada um desses feeds devolve cerca de 20 posts por página, do mais novo para o mais antigo, com os mesmos campos de post.

• Uma conta. POST /user-tweets (abre em uma nova aba) com "username" e "type": "posts" lê os posts da própria conta, sem respostas, então não é preciso uma Lista.
• Sua Lista, mas só quando importa. POST /search-tweets (abre em uma nova aba) com o operador list: alerta apenas quando os membros da Lista usam as suas palavras, por exemplo uma palavra de lançamento ou uma cashtag.
• Qualquer pessoa dizendo uma palavra. Tire o list: da busca para captar o nome de uma marca, uma hashtag ou um ticker de qualquer conta pública. O guia de operadores de busca do Twitter explica lang:, min_faves: e o resto da sintaxe.
• Menções a um @. POST /mentions (abre em uma nova aba) devolve posts que marcam uma conta, e o guia da API de menções do Twitter a combina com uma busca pelo nome para os posts que nunca a marcam.

Dentro do script, a verificação de Lista com palavra-chave troca a chamada list-tweets por esta busca. O since_id: limita cada verificação aos posts mais novos que o seu ponto de controle:

query = (f"list:{LIST_ID} (mainnet OR $NWND) -filter:replies "
         f"since_id:{last_id}")
r = requests.post(f"{API}/search-tweets", headers=HEADERS,
                  json={"query": query, "order": "latest"}, timeout=30)

Bom saber

Os alertas cobrem apenas dados públicos. Uma Lista privada não pode ser lida, e contas protegidas nunca aparecem em nenhum feed, então mantenha a Lista pública. A Sorsa API é somente leitura por princípio: nunca publica, curte nem segue, e nunca pede o seu login no X, então a conta que você usa no X não corre nenhum risco.

#Configure seu primeiro alerta de tweet

Para uma conta que você segue, o sino leva um minuto para configurar e não custa nada. Para uma lista de monitoramento, um chat de equipe ou alertas por palavras, coloque as contas em uma Lista pública do X e deixe a Sorsa API verificá-la: uma requisição cobre até 5.000 contas, uma verificação por minuto cabe no plano Pro, e o script acima envia cada lote novo ao Telegram ou ao Slack. Suas 100 requisições grátis rodam as primeiras 100 verificações.

#Perguntas frequentes