ACCOUNT ACTIVITY
Twitter Account Activity API: Polling Alternative
Updated July 2026
The Account Activity API is a first-party webhook product on X's enterprise tier: X posts account events to an HTTPS endpoint you host. The alternative is incremental polling, where a scheduled job calls ordinary REST endpoints and treats anything above a stored watermark as new. TwitterAPIs covers mentions, replies, reposts, follows and DMs that way at $0.0008 per call, with no webhook receiver to operate.
We bill each poll at $0.0008 (source: our published pricing), so a five-minute mention watch runs about $1.15 a month.
Which activity events polling can reach
Most of what the webhook product delivers is public data that a read can reach. The exceptions are private account state, and they are listed here rather than quietly omitted, because discovering a gap after you have built against it is the expensive way to learn it.
| Activity event | Status | How you watch it | Docs |
|---|---|---|---|
| Mentions of an account | Covered | GET /twitter/user/mentions, newest first, watermarked on the top post ID | View docs |
| Replies under a post | Covered | GET /twitter/tweet/replies against the post you are watching | View docs |
| New posts by an account | Covered | GET /twitter/user/tweets, comparing the top ID against your last run | View docs |
| Reposts of a post | Covered | GET /twitter/tweet/retweeters, diffed against the set you already stored | View docs |
| New followers | Covered | GET /twitter/user/followers, diffed against your stored follower set | View docs |
| Direct messages | Covered | GET /twitter/dm/list and /twitter/dm/conversation on a registered session | View docs |
| Blocks, mutes and typing indicators | Not covered | Private account state that X exposes only to its own first-party webhook product | None |
Webhooks and polling, compared honestly
Push wins on latency. Polling wins on everything you have to operate. Which matters depends entirely on whether a minute of delay changes your outcome.
| Dimension | X Account Activity webhooks | Polling on TwitterAPIs |
|---|---|---|
| Delivery | X posts each event to a public HTTPS endpoint you host | Your job asks for what is new on a schedule you control |
| Access | Enterprise access to X's Account Activity product | A Bearer token issued at signup, no application to file |
| Infrastructure | A public endpoint, a CRC challenge responder, signature validation, and replay handling | A cron entry and somewhere to store one watermark per watch |
| Latency | Seconds, pushed as the event happens | Bounded by your interval, so a 60-second cron means under a minute |
| Missed events | A failed delivery while your endpoint is down can be lost | Nothing is lost, because the next run reads from the stored watermark forward |
| Cost shape | Enterprise contract, priced per month | $0.0008 per call, so cost is your interval multiplied by your watches |
If you genuinely need signed sub-second push delivery, X's own product is the right tool and nothing here replaces it. For brand monitoring, support triage and agent inboxes, the delay is usually irrelevant and the operational saving is not.
The watermark loop, which is the whole pattern
Store one value per watch: the highest post ID you have already processed. Each run reads newest first, stops at the watermark, and handles everything above it. The loop is idempotent, so a double run processes nothing twice, and it self-heals after an outage because the watermark did not move while the job was down.
1import requests23BASE = "https://api.twitterapis.com"4HEAD = {"Authorization": "Bearer YOUR_API_KEY"}56def poll_mentions(user_name, watermark):7 """Return (new_events, new_watermark). Pages until it reaches the watermark."""8 fresh, cursor, top = [], None, watermark9 while True:10 params = {"username": user_name}11 if cursor:12 params["cursor"] = cursor13 body = requests.get(14 f"{BASE}/twitter/user/mentions", params=params, headers=HEAD15 ).json()1617 for post in body.get("tweets", []):18 if watermark and int(post["id"]) <= int(watermark):19 return fresh, top # caught up, stop paging20 if top is None or int(post["id"]) > int(top):21 top = post["id"]22 fresh.append(post)2324 if not body.get("has_more"):25 return fresh, top26 cursor = body["next_cursor"]2728# run this on a cron; persist the watermark between runs29events, watermark = poll_mentions("nasa", watermark=None)30print(len(events), "new mentions, watermark now", watermark)The detail that matters is the inner paging loop. Reading only the first response is what makes naive polling drop events during a burst, because a spike can push more than one page of activity between two runs. Keep following next_cursor until you reach the watermark, and a burst arrives complete.
What a continuous watch costs
$1.15
per month, one account polled every 5 minutes
$34.56
per month, one account polled every minute
$0
subscription, contract, and enterprise minimum
Both figures assume one call per run at the standard $0.0008 rate, which holds while activity fits a single page. Since we impose no rate-limit windows, interval is purely a cost decision: poll a high-value account every minute and sweep a long tail hourly on the same key. Size a mixed workload on the Twitter API cost calculator.
Narrower surfaces for a single event type
If mentions are the only event you care about, the Twitter mentions API goes deeper on that one loop. Follower-change watches are covered on the Twitter followers API, and to react to an event rather than only record it, the Twitter engagement API covers replying, liking and reposting from the same key. The Twitter REST API overview documents the paging and error contract every watch depends on.
By the numbers
Activity monitoring, in numbers.
Sourced figures behind event access and cost.
X's Account Activity API is an enterprise product, sold under contract rather than self-serve sign-up. (X Developer Platform, 2026)
Official X API polling endpoints meter requests in 15-minute windows, which is what pushes most monitoring builds toward webhooks. (X API docs, 2026)
TwitterAPIs bills each poll at $0.0008 with no rate-limit window, so a one-minute mention watch is about $34.56 a month. (TwitterAPIs pricing, 2026)
Mentions, replies, reposters, followers and DM threads are each readable on a cursor-paged endpoint suitable for watermarked polling. (TwitterAPIs docs, 2026)
A new account starts with $0.50 in free credit and no card, enough to run a five-minute watch for roughly two weeks. (TwitterAPIs pricing, 2026)
Account activity, common questions
The Account Activity API is X's first-party webhook product. Rather than you asking for new data, X posts account events to an HTTPS endpoint you host, covering mentions, replies, follows, direct messages and similar activity for accounts that have authorised your app. It is enterprise-tier access, which means an application, an approved app, a subscription, and a public endpoint of your own that answers a CRC challenge and validates signatures on every delivery.
No, and it is worth being direct about that rather than implying otherwise. We serve REST endpoints that you call; we do not post events to a URL you host. If your requirement is genuinely sub-second push delivery with a signed payload, X's own Account Activity product is the correct tool and no third-party API replaces it. If your requirement is knowing about mentions, replies, follows and DMs promptly and reliably, a polling loop against these endpoints does that with far less to operate.
Match the interval to how quickly a missed event actually hurts. Support triage and brand alerting are usually fine at 60 seconds, which is 43,200 calls a month per watch, roughly $34.56 at the standard rate for a single continuously polled account, or about $1.15 a month at a five-minute interval. Because there are no rate-limit windows on our side, a tighter interval is a pure cost decision rather than a quota one, and you can poll a high-value account fast while sweeping a long tail hourly.
Only for private surfaces. Mentions, replies, new posts, reposters and follower lists are public, so your Bearer token alone is enough. Direct messages are not public, so those read against a registered X session, which you set up once with a free call to POST /twitter/customer/session using auth_token and ct0 for the account you control. Everything else on this page needs no session at all.
Incremental polling covers most of the same ground at a fraction of the operational weight. Instead of hosting a webhook receiver, a scheduled job calls ordinary REST endpoints, stores the newest ID it has already seen, and treats anything above that watermark as a new event. TwitterAPIs bills those calls at $0.0008 each with no plan, so a mention watch polling once a minute costs roughly $1.15 a month. What you trade away is push latency: events surface within your interval rather than within seconds.
Store one value per watch: the highest post ID you have already processed. On each run, call GET /twitter/user/mentions for the account, walk the returned posts from newest down, stop as soon as you reach an ID at or below your stored watermark, and handle everything above it as new. Then save the new top ID. That loop is idempotent, so a duplicate run processes nothing twice, and it self-heals after downtime because the watermark has not moved while your job was off.
No, provided you page rather than only reading the first response. The watermark is what guarantees completeness: anything published between two runs still sits above your stored ID on the next call, so you catch it late rather than not at all. The one case that needs care is a burst larger than a single page. Keep following next_cursor until you reach an ID at or below your watermark, instead of assuming one page covers the gap.
Watch account activity without an enterprise contract
$0.0008 a poll, $0.50 in free credit. Mentions, replies, reposts, follows and DMs on one Bearer key.
Next read
Continue exploring related pages:
Twitter engagement API
Like, repost and bookmark from code, then read what moved.
Twitter followers API
Export any account's followers and following with cursor pagination, $0.04 per 1,000.
Twitter REST API
The auth header, paging model and error contract in one place.
Twitter API cost calculator
Estimate monthly spend using your request volume.