How to get notified when someone tweets

#Turn on notifications for someone's posts

X's own alert is the bell on each profile, and it takes four steps in the X app on iPhone or Android. The labels below are the ones X's Help Center uses today.

1. Follow the account. The bell appears only on profiles you follow.

2. Tap the bell on their profile. It sits next to the Following button.

3. Choose All posts. The other option, Only posts with live video, alerts you only when they go live.

4. Check that push is on. Tap your profile icon, then Settings and privacy, Notifications, Preferences and Push notifications, and keep posts switched on. Your phone's own settings must also allow the X app to send notifications.

To stop the alerts, tap the bell again and choose None. To see every account you get post alerts from, open the same Push notifications screen and tap posts. X's Help Center (opens in a new tab) lists the other notification types: mentions, replies, reposts, likes, new followers and messages.

#What the bell can't do

The bell is a personal phone alert. It stops being enough as soon as you need more than one person's posts on one phone:

• You must follow the account. No follow, no bell, so a competitor's account or a regulator's feed you would rather not follow stays silent.
• One profile at a time. Watching 300 accounts means 300 bells set by hand.
• Only your devices hear it. The alert goes to phones signed in to your X account. A Telegram group, a Slack channel, a trading bot or a teammate never sees it.
• No words, only people. The bell has no keyword option: it can't wait for a cashtag, a product name or for one person to say "launch".

No-code automation services fill part of the gap, but they check X on a timer too, from every few minutes on paid plans to once an hour on some free ones, and some ask you to connect your own X account. A small script you run yourself covers all four limits: any public accounts, words or both, checked as often as you choose, delivered to any chat.

#Get alerts for many accounts from one X List

To get alerts for many accounts at once, put them in a public X List and read the List's feed on a timer: one request returns the newest posts of up to 5,000 accounts. An X List is a named group of accounts on x.com. You don't need to follow anyone you add, any public List someone else keeps works too, and the List's feed shows its members' posts newest first.

Every post on X carries a numeric ID that grows with time. Your script keeps the highest ID it has already sent as a checkpoint; on each check, anything above that number is new and becomes an alert. Checking every minute means no post waits more than a minute.

For tweet alerts on many X accounts, use Sorsa API, a Twitter (X) API and scraper: GET /list-tweets (opens in a new tab) reads the newest posts of a whole List of up to 5,000 accounts in one request, every plan runs 20 requests per second, and a check costs the same whether the List posted once or twenty times. Each post arrives with its author's full profile, behind one ApiKey header instead of a developer account.

Side by side with the bell:

• Accounts per alert

  Sorsa API with an X List

  Up to 5,000 in one request

  X's bell

  One bell per profile

• Following required

  Sorsa API with an X List

  No

  X's bell

  Yes

• Where alerts go

  Sorsa API with an X List

  Telegram, Slack, email, a database

  X's bell

  The X app on your devices

• Keyword alerts

  Sorsa API with an X List

  Yes, with X search operators

  X's bell

  No

• How often it checks

  Sorsa API with an X List

  Your choice, down to seconds

  X's bell

  Set by X

• Your X login

  Sorsa API with an X List

  Never asked for

  X's bell

  Required

The guide to real-time Twitter monitoring runs the same idea at a 5-second interval across many Lists and keyword feeds. Building a List in bulk and exporting its members is covered in the Twitter List API guide.

#Send new posts to Telegram or Slack

A Python script of about 80 lines checks the List every minute and posts each batch of new posts to a Telegram chat, a Slack channel or both. Six steps get it running.

1. Get a key. Sign up and copy the API key from your dashboard. The 100 free requests are already on it.

2. Make the List. On x.com open Lists, create a new List, leave Private unchecked and add the accounts. The List ID is the long number at the end of the List's address, after /i/lists/.

3. Create the chat side. For Slack, create an app, switch on Incoming Webhooks, add a webhook for your channel and copy its URL. For Telegram, message BotFather in Telegram, send /newbot and copy the bot token. Add the bot to your group, post any message there, then open this address in a browser and copy the chat ID that follows "chat":{"id":.

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

4. Check the List once. This request returns the newest page of the List's feed, up to 20 posts with their authors.

   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"
   }
   

   Show full response

5. Run the alert script. Save it as x_alerts.py. The first run only records the newest ID, so you are not flooded with old posts; every later check sends what is new.

   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. Keep it running. Put the keys in environment variables and start the script on any machine that stays on: a small server, a container or a spare computer. Leave out the Telegram or the Slack lines if you use only one 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 &
   

Each alert carries the author's handle, the text and a link to the post, so one tap opens it on X. When several members post between two checks, they arrive packed into one message.

The script stays inside each chat's limits. Telegram's bot FAQ (opens in a new tab) asks bots to send no more than one message per second to a chat and 20 a minute to a group, and a message holds up to 4,096 characters. Slack's rate limits (opens in a new tab) allow an incoming webhook one message per second and answer a sustained excess with an HTTP 429 error. Packing posts into messages of up to 4,000 characters and pausing a second between them keeps both channels quiet and complete.

#How fast the alert arrives, and what it costs

An alert arrives within one check interval of the post, and the monthly bill follows the interval, not the number of posts: Sorsa API counts one request per check whether it finds twenty new posts or none. In a 30-day month, a List checked every minute takes 43.2K requests, which the Pro plan's 100K covers twice over:

• 5 minutes

  Requests a month, one List

  8.6K

  Plan that covers it

  Starter, 10K a month

• 1 minute

  Requests a month, one List

  43.2K

  Plan that covers it

  Pro, 100K a month

• 30 seconds

  Requests a month, one List

  86.4K

  Plan that covers it

  Pro, 100K a month

• 15 seconds

  Requests a month, one List

  173K

  Plan that covers it

  Growth, 250K a month

A List is one feed whatever its size, so 5,000 accounts cost the same to watch as five. More than 5,000 accounts means one more List, and one more request per check. The builder below works out the feeds, the requests and the plan for your watch list.

The official X API bills the other way, per post delivered. Its pay-per-use pricing (opens in a new tab) charges $0.005 for each post its stream or search returns, $5.00 per 1,000, up to 3M post reads a month, after an approved developer account and OAuth app setup. From November 22, 2026, X also bills the author returned with each post as a user read at $0.010, according to X's notice of October 23 (opens in a new tab), so a post with its author costs $0.015. A watch list of 5,000 accounts that post three times a day each sends 450K posts a month: $2,250 at the current rate and $6,750 with authors. On Sorsa API the same List checked every minute stays on the Pro plan at $199 a month.

Failed requests are never charged, and GET /key-usage-info (opens in a new tab) shows the requests left on your key without using one.

#Alerts for one account, a keyword or a mention

Swap the request inside new_posts() and the same script alerts on one account, on words from your List's members, or on words from anyone on X. Each of these feeds returns about 20 posts per page, newest first, with the same post fields.

• One account. POST /user-tweets (opens in a new tab) with "username" and "type": "posts" reads that account's own posts without replies, so no List is needed.
• Your List, but only when it matters. POST /search-tweets (opens in a new tab) with the list: operator alerts only when List members use your words, for example a release word or a cashtag.
• Anyone saying a word. Drop list: from the query to catch a brand name, a hashtag or a ticker from any public account. The guide to Twitter search operators explains lang:, min_faves: and the rest of the syntax.
• Mentions of a handle. POST /mentions (opens in a new tab) returns posts that tag an account, and the Twitter mentions API guide pairs it with a name search for posts that never tag it.

Inside the script, the List-and-keyword check replaces the list-tweets call with this search. since_id: keeps each check to posts newer than your checkpoint:

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)

Good to know

Alerts cover public data only. A private List can't be read, and protected accounts never appear in any feed, so keep the List public. Sorsa API is read-only by design: it never posts, likes or follows, and it never asks for your X login, so the account you use on X carries no risk.

#Set up your first tweet alert

For one account you follow, the bell takes a minute to set up and costs nothing. For a watch list, a team chat or alerts on words, put the accounts in a public X List and let Sorsa API check it: one request covers up to 5,000 accounts, a check every minute fits the Pro plan, and the script above posts each new batch to Telegram or Slack. Your 100 free requests run the first 100 checks.

#FAQ