Real-time Twitter monitoring API

#How real-time Twitter monitoring works

Real-time Twitter monitoring is a loop. It asks X for the newest posts in a feed, keeps the ones it has not handled yet and asks again a few seconds later. That loop is called polling. The feed can be one account, a List of accounts or a search for words: a brand name, a rival's handle, a cashtag, an outage keyword or the analysts whose posts move a market.

Every post on X carries a numeric ID that grows with time, so the highest ID you have processed works as a checkpoint: anything above it is new. The interval between polls sets the longest wait. A post published right after a poll waits one full interval for the next one; a post published right before a poll is caught at once.

The official X API works the other way, by push. Its Filtered Stream keeps one HTTP connection open and sends every post that matches your rules, and X's Filtered Stream documentation (opens in a new tab) puts the delay at about 4 to 5 seconds for 99% of posts. Pay-per-use access allows 1 connection, 1,000 rules of up to 1,024 characters and 250 posts per second, and it needs an approved developer account, a project, an app and a Bearer token.

X bills each post the stream delivers as a post read: $0.005, or $5.00 per 1,000, up to 3M post reads a month before an Enterprise contract. From November 22, 2026, an author profile returned with a post costs $0.010 more, according to X's notice of October 23 (opens in a new tab), so a post with its author comes to $0.015. Every other official rate is broken down in the guide to X API pricing.

#Monitor accounts and keywords with Sorsa API

For monitoring X from code, use Sorsa API, a Twitter (X) API and scraper: one request reads the newest posts of up to 5,000 accounts, keyword feeds take X's own search syntax, and every plan runs 20 requests per second. Each poll returns fresh data, every post with its author's full profile, behind one ApiKey header instead of a developer account and OAuth.

Pick the endpoint by what you watch. Each one returns a page of about 20 posts, newest first, and a next_cursor to the page before it.

• Up to 5,000 accounts

  Endpoint

  GET /list-tweets (opens in a new tab)

  What one request returns

  The newest posts from every member of a public List

• One account

  Endpoint

  POST /user-tweets (opens in a new tab)

  What one request returns

  Its newest posts, replies or reposts

• Words, hashtags, cashtags

  Endpoint

  POST /search-tweets (opens in a new tab)

  What one request returns

  The newest matches with "order": "latest"

• Posts that tag a handle

  Endpoint

  POST /mentions (opens in a new tab)

  What one request returns

  The newest mentions, with like and date filters

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

2. Put the accounts in a public X List. Create a List on x.com, add up to 5,000 accounts and leave it public: no API key can read a private List. The List ID is the number at the end of the List's address on x.com, and it is the list_id the request below sends.

3. Poll the List. One GET request returns the newest posts of all members at once, each with its author's profile.

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

   {
     "tweets": [
       {
         "id": "2117190277605314310",
         "full_text": "Status update: EU-West checkout errors are resolved.",
         "created_at": "2026-11-02T09:41:12Z",
         "lang": "en",
         "likes_count": 14,
         "retweet_count": 5,
         "reply_count": 3,
         "quote_count": 1,
         "view_count": 2140,
         "is_reply": false,
         "conversation_id_str": "2117190277605314310",
         "user": {
           "id": "1702291101836602498",
           "username": "harborline_status_hq",
           "display_name": "Harborline Status",
           "followers_count": 48210,
           "verified": false
         }
       },
       {
         "id": "2117190206607470143",
         "full_text": "Our Q3 freight index is out: spot rates down 4%.",
         "created_at": "2026-11-02T09:40:55Z",
         "lang": "en",
         "likes_count": 31,
         "retweet_count": 9,
         "reply_count": 4,
         "quote_count": 2,
         "view_count": 5320,
         "is_reply": false,
         "conversation_id_str": "2117190206607470143",
         "user": {
           "id": "1366689741639744314",
           "username": "quaywright_analytics",
           "display_name": "Quaywright Analytics",
           "followers_count": 12904,
           "verified": true
         }
       }
     ],
     "next_cursor": "DAABCgABG3kQ8x7_7ToKAAIbeRDz9yz3QAgAAwAAAAIAAA"
   }
   

   Show full response

4. Keep only new posts. Compare each ID with your checkpoint, follow next_cursor when more than one page arrived since the last poll, and skip IDs you already handled. The loop below does all three every 5 seconds and re-checks the last 2 minutes of IDs, so a post that reaches the feed late still gets caught.

   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   LIST_ID = "1849722563900214388"
   INTERVAL = 5              # seconds between polls
   OVERLAP = 120_000 << 22   # re-check the last 2 minutes of IDs
   
   
   def read_newer(floor):
       """Read pages until posts at or below floor show up."""
       posts, params = [], {"list_id": LIST_ID}
       for _ in range(5):  # at most 5 pages per poll
           r = requests.get(f"{API}/list-tweets", headers=HEADERS,
                            params=params, timeout=30)
           r.raise_for_status()
           page = r.json()
           tweets = page.get("tweets", [])
           newer = [t for t in tweets if int(t["id"]) > floor]
           posts += newer
           cursor = page.get("next_cursor")
           if not floor or len(newer) < len(tweets) or not cursor:
               break
           params["next_cursor"] = cursor
       return sorted(posts, key=lambda t: int(t["id"]))
   
   
   def handle(t):
       print(t["user"]["username"], t["created_at"], t["full_text"][:80])
   
   
   last_id, seen, first = 0, set(), True
   while True:
       try:
           posts = read_newer(max(last_id - OVERLAP, 0))
       except requests.RequestException as err:
           print("poll failed, retrying:", err)
           time.sleep(INTERVAL * 2)
           continue
       for t in posts:
           if t["id"] not in seen:
               seen.add(t["id"])
               if not first:  # the first poll only sets the checkpoint
                   handle(t)
           last_id = max(last_id, int(t["id"]))
       first = False
       time.sleep(INTERVAL)
   

   const API = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY" };
   const LIST_ID = "1849722563900214388";
   const INTERVAL = 5_000;           // 5 seconds between polls
   const OVERLAP = 120_000n << 22n;  // re-check the last 2 minutes of IDs
   
   const sleep = (t) => new Promise((r) => setTimeout(r, t));
   
   async function readNewer(floor) {
     const posts = [];
     const params = new URLSearchParams({ list_id: LIST_ID });
     for (let i = 0; i < 5; i++) {
       const res = await fetch(`${API}/list-tweets?${params}`, { headers });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       const tweets = page.tweets ?? [];
       const newer = tweets.filter((t) => BigInt(t.id) > floor);
       posts.push(...newer);
       if (!floor || newer.length < tweets.length || !page.next_cursor) break;
       params.set("next_cursor", page.next_cursor);
     }
     return posts.sort((a, b) => (BigInt(a.id) < BigInt(b.id) ? -1 : 1));
   }
   
   let lastId = 0n;
   let first = true;
   const seen = new Set();
   while (true) {
     try {
       const floor = lastId > OVERLAP ? lastId - OVERLAP : 0n;
       for (const t of await readNewer(floor)) {
         if (!seen.has(t.id)) {
           seen.add(t.id);
           if (!first) console.log(t.user.username, t.full_text.slice(0, 80));
         }
         if (BigInt(t.id) > lastId) lastId = BigInt(t.id);
       }
       first = false;
     } catch (err) {
       console.error("poll failed, retrying:", err.message);
       await sleep(INTERVAL);
     }
     await sleep(INTERVAL);
   }
   

5. Add keyword feeds. For a brand or a cashtag, poll POST /search-tweets with "order": "latest" and put the since_id: operator in the query, so each poll returns only newer matches. Native reposts stay out of results unless the query adds include:nativeretweets, and the guide to the Twitter search API lists the other operators.

   floor = max(last_id - OVERLAP, 0)
   query = '("lumenforge" OR #lumenforge OR $LMFG) lang:en'
   body = {"query": f"{query} since_id:{floor}", "order": "latest"}
   r = requests.post(f"{API}/search-tweets", headers=HEADERS,
                     json=body, timeout=30)
   

6. Send each new post where it is needed. The handle() function is yours to replace: write the post to a database, post it to a team channel in Slack, or pass it to an AI agent that sorts and summarizes.

#One X List covers 5,000 accounts

An X List turns thousands of accounts into one feed, and that is what keeps polling cheap at scale. Watching 5,000 accounts one by one takes 5,000 timeline requests on every poll. Put them in one public List and every poll is a single request to GET /list-tweets, however many of the members posted.

The rate limit then stops being the bottleneck. Sorsa API allows 20 requests per second per key on every plan, free accounts included. One key can poll 20 Lists every second, or 600 Lists covering up to 3M accounts every 30 seconds. On the official X API, the List timeline endpoint allows 900 requests per 15 minutes per app, about one a second, and bills every post it returns. The guide to X API rate limits has the full table.

Each request returns about 20 posts. When a List publishes more than that between two polls, the loop above follows next_cursor back to the checkpoint, at one more request per extra page. A shorter interval does the same job. Reading a List's members and followers, and building Lists in bulk, is covered in the X Lists and Communities API guide.

#How often to poll, and what it costs

Pick the interval from the longest wait your job accepts, then count polls. Sorsa API bills one request per poll whether the page holds 20 new posts or none, so the monthly cost follows two numbers: how many feeds you poll and how often. In a 30-day month, one feed polled every 30 seconds makes about 86K requests, which fits the Pro plan's 100K. Per feed, each interval comes to:

• 5 seconds

  Requests a month

  518K

  From

  $726

  At the Pro rate

  $1,032

• 15 seconds

  Requests a month

  173K

  From

  $242

  At the Pro rate

  $344

• 30 seconds

  Requests a month

  86K

  From

  $121

  At the Pro rate

  $172

• 1 minute

  Requests a month

  43K

  From

  $60

  At the Pro rate

  $86

• 5 minutes

  Requests a month

  8.6K

  From

  $12

  At the Pro rate

  $17

The "From" column uses Sorsa API's lowest rate, $1.40 per 1,000 requests; the Pro rate is $1.99. A feed here is one List of up to 5,000 accounts or one search query, so 5,000 accounts polled every 30 seconds cost the same as one. The planner below adds feeds and shows which plan covers them.

Per post, a busy feed is where the difference shows. A List or a search that fills its page of 20 on each poll collects posts from $0.07 per 1,000 on Sorsa API. The official X API bills $5.00 per 1,000 posts its stream delivers, and $15.00 per 1,000 once it bills the author returned with each post from November 22.

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

#Social listening on X with an API

Social listening on X means collecting what people post about a brand, a product or a topic, then turning it into numbers: volume, sentiment, reach and the accounts that drive the talk. A listening tool does that inside its own dashboard. With an API you collect the posts yourself and compute the numbers in your code, your data warehouse or your AI agent.

Compared with the X connector of a multi-network listening tool, a dedicated X data API gives you:

• the full replies, quotes and reposters of any public post, page by page;
• X's own search syntax, from exact phrases to lang:, min_faves: and from:;
• searches over any date window back to 2006, to benchmark a launch against past ones;
• the author's full profile inside every post, with no extra call;
• raw JSON with no seats and no export caps, at a flat price per request.

Brand mentions come from two feeds: POST /mentions catches posts that tag your handle, and a name search catches the posts that never do. The Twitter mentions API guide merges both on tweet ID. Around any post that takes off, POST /comments (opens in a new tab), POST /quotes (opens in a new tab) and POST /retweeters (opens in a new tab) read the replies, the quote posts and the accounts that reposted it. GET /followers (opens in a new tab) reads an audience 200 profiles a page, GET /info-batch (opens in a new tab) reads 100 profiles at once, and GET /trends (opens in a new tab) returns what is trending in a country or city by its WOEID.

The metrics a team computes from the feed

• Share of voice: run the same query for your brand and for each competitor over the same window, then compare matched posts and the views and follower reach behind them. The guide to Twitter competitor analysis builds the full comparison.
• Sentiment: classify each post's text as positive, negative or neutral with your own model or an LLM, as in our guide to Twitter sentiment analysis.
• Reach and amplification: add up view_count, retweet_count and quote_count for the posts in a window.
• Top voices: rank authors by followers_count and by the engagement their posts earned.

For social listening on X from code, Sorsa API returns search results from $0.07 per 1,000 with history back to 2006, and the same key runs the live monitor above.

#Keep the monitor reliable

A monitor that runs for months meets restarts, bursts and posts that arrive out of order. Five habits keep it from missing posts or reporting one twice:

• Store the checkpoint. Keep the last ID in a database row or a file, so a restart resumes where it stopped instead of replaying old posts or skipping new ones.
• Re-check a short overlap. A post can reach a List or search feed a few seconds after a newer one. Reading back 2 minutes of IDs on each poll and skipping IDs already handled catches those late arrivals.
• Compare IDs, not positions. POST /user-tweets can return an account's pinned post first, so take the highest ID on the page as the newest.
• Back off on errors. A 429 means the key went past 20 requests per second: wait and retry. A 403 means the key has no requests left. Neither costs anything, because failed requests are not charged.
• Refresh the counts later. A post caught seconds after it went up has almost no likes or views yet. Re-read the posts you kept an hour later with POST /tweet-info-bulk (opens in a new tab), 100 per request, which puts known tweets from $0.014 per 1,000.

Good to know

Polling reads public data only. Protected accounts, private Lists and direct messages never appear in any feed. Sorsa API is read-only by design: it never posts, likes or follows, and it never asks for your X login, so your own X account carries no risk.

#Start your first real-time monitor

Real-time Twitter monitoring comes down to an interval and a checkpoint: a 5-second loop over a public List watches 5,000 accounts with one request per poll. Sorsa API runs that loop on one API key at 20 requests per second on every plan, with collected posts from $0.07 per 1,000 against $5.00 on the official X API. Put your accounts in a List, run the loop above on your 100 free requests, and add keyword feeds once the first posts come in.

#FAQ