Twitter Mentions API: Monitor Any Account at $0.04/1K

What is the Twitter Mentions API?

Endpoint: GET /twitter/user/mentions. Pass any public username and receive an array of tweets that mentioned that account, sorted newest first. Each tweet includes the full text, author, timestamp, conversation ID, and public metrics. The response carries a next_cursor and has_more for cursor pagination. Because results come newest first, storing the highest tweet ID you have processed makes every later poll incremental on your side. Cost: $0.0008 per call, or about $0.04 per 1,000 mentions pulled. No X developer account required.

Pull new mentions with a polling loop

The mentions endpoint lives at GET /twitter/user/mentions and returns tweets newest first. On the first call, take the most recent page and store the highest tweet ID you see. On every later call, keep only tweets with a higher ID and drop the rest, so each poll stays incremental. Tweet IDs grow with time, so an integer comparison is enough; if the whole page is new, follow next_cursor until you reach an ID you have already processed.

First pull + ongoing polling loop

# Every poll: the latest mentions of @yourhandle, newest first
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/mentions?username=yourhandle&count=50"

# Keep only tweets whose id is above the highest id you stored last time.

import time
import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://api.twitterapis.com/twitter/user/mentions"
HANDLE = "yourhandle"
POLL_INTERVAL = 60  # seconds
MAX_PAGES = 5  # cap a burst catch-up

def fetch_mentions(cursor=None):
    params = {"username": HANDLE, "count": 50}
    if cursor:
        params["cursor"] = cursor
    resp = requests.get(
        BASE,
        params=params,
        headers={"Authorization": f"Bearer {API_KEY}"},
    )
    return resp.json()

def new_mentions(latest_id):
    """Tweets above latest_id, newest first. Tweet ids grow with time."""
    found, cursor = [], None
    for _ in range(MAX_PAGES):
        data = fetch_mentions(cursor)
        tweets = data.get("tweets", [])
        fresh = [t for t in tweets if int(t["id"]) > latest_id]
        found.extend(fresh)
        if len(fresh) < len(tweets) or not data.get("has_more"):
            break
        cursor = data.get("next_cursor")
    return found

def monitor():
    latest_id = 0  # persist this outside the process
    while True:
        fresh = new_mentions(latest_id)
        for tweet in reversed(fresh):  # oldest first
            print(tweet["id"], tweet["text"][:80])
        if fresh:
            latest_id = max(int(t["id"]) for t in fresh)
        time.sleep(POLL_INTERVAL)

monitor()

const API_KEY = "YOUR_API_KEY";
const HANDLE = "yourhandle";
const POLL_MS = 60_000; // 60 seconds
const MAX_PAGES = 5; // cap a burst catch-up

async function fetchMentions(cursor = null) {
  const url = new URL("https://api.twitterapis.com/twitter/user/mentions");
  url.searchParams.set("username", HANDLE);
  url.searchParams.set("count", "50");
  if (cursor) url.searchParams.set("cursor", cursor);
  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${API_KEY}` },
  });
  return res.json();
}

// Tweet ids grow with time; compare them as BigInt, never as numbers.
async function newMentions(latestId) {
  const found = [];
  let cursor = null;
  for (let page = 0; page < MAX_PAGES; page++) {
    const data = await fetchMentions(cursor);
    const tweets = data.tweets ?? [];
    const fresh = tweets.filter((t) => BigInt(t.id) > latestId);
    found.push(...fresh);
    if (fresh.length < tweets.length || !data.has_more) break;
    cursor = data.next_cursor;
  }
  return found;
}

async function monitor() {
  let latestId = 0n; // persist this outside the process
  while (true) {
    const fresh = await newMentions(latestId);
    for (const t of [...fresh].reverse()) console.log(t.id, t.text.slice(0, 80));
    for (const t of fresh) if (BigInt(t.id) > latestId) latestId = BigInt(t.id);
    await new Promise((r) => setTimeout(r, POLL_MS));
  }
}

monitor();

Each call costs $0.0008. A 60-second polling loop runs about 1,440 calls per day, which is $1.15 per day or about $34.56 per month. Stretching the interval to 5 minutes drops monthly cost to $6.91 with no code changes beyond the sleep duration. Read the mentions endpoint docs.

See it in action: one account, one poll cycle

The loop is small enough to read in full. Each call returns the current page of mentions, newest first. You record the highest tweet ID you processed. On the next call you keep only what sits above it, so a quiet minute costs $0.0008 and adds nothing to your queue, rather than handing your pipeline the same twenty tweets again.

# 1. Cold start: the current page, newest first.
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/mentions?username=jack"

# -> { "tweets": [ ... ], "count": 20,
#      "next_cursor": "...", "has_more": true }
# Record the highest id you saw, say 1799342211110000000.

# 2. A minute later, the same call.
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/mentions?username=jack"

# -> 20 tweets again; 2 have an id above 1799342211110000000.
# Keep those 2, drop the other 18. One call, $0.0008, quiet or busy.

What that costs over a month is arithmetic rather than a plan. One call a minute is 43,200 calls, about $34.56. One call every five minutes is 8,640 calls, about $6.91. Nothing about those numbers changes with how many mentions come back, which is the part a per-result pricing model gets wrong for a monitoring workload: a viral day and a dead day cost the same to watch.

Two failure modes worth designing for on the first pass. If your poller crashes and restarts without the stored anchor, it cold-starts and re-delivers a page you have already processed, so persist the anchor outside the process. And if a burst exceeds one page, has_more comes back true: keep paging with next_cursor until you reach an ID at or below the stored one before you advance the anchor, or you will skip the older half of the burst.

Monitor any Twitter search query, not just @mentions

The mentions endpoint answers one question: who tagged this handle. That is a narrower question than most brand monitoring actually needs, because the posts that matter often do not tag anyone. Someone complaining about your product by name, a competitor comparison thread, a misspelling of your brand, a link to your domain with no handle attached: none of those appear in a mentions response.

For those, poll GET /twitter/tweet/advanced_search on the same schedule and with the same key. It takes an X search query, so operators you already know work: quoted phrases, OR, exclusions, from: and url:. One call, same $0.0008, same 600 requests per minute ceiling.

# Untagged brand mentions, misspellings, and link drops,
# minus your own account's posts.
QUERY='("acme corp" OR "acmecorp" OR url:acme.com) -from:acmecorp'

curl -H "Authorization: Bearer YOUR_API_KEY" \
  --get "https://api.twitterapis.com/twitter/tweet/advanced_search" \
  --data-urlencode "query=$QUERY"

# Same envelope as mentions: tweets, count, next_cursor, has_more.
# Dedupe against your mentions loop on tweet id, since a post that
# both tags you and names you will arrive on both.

One honest limit. Our webhook monitors watch a handle, optionally narrowed by a domain filter or by turning replies off, so keyword and hashtag tracking is a polling loop rather than a push subscription today. That is a real difference in operational shape, not just in wiring: a poll has a floor on how fresh it can be, and at one call a minute that floor is a minute. If your use case is a support inbox, that is fine. If it is a live incident feed, poll faster and price it, or use the handle monitor for the part that can be pushed.

Brand mentions: what counts as one

X's own Notifications tab shows the mentions of the account you are signed in as, and only that account. The mentions endpoint has no such limit: it reads the mentions of any public handle, which is what makes it useful for a client, a competitor or a founder's personal account as well as your own brand.

The endpoint returns what X files as directed at that account, replies included. To be sure you also catch posts that tag the handle in passing, add the handle itself, such as @acmecorp, to the search loop above. A brand mention in the wider sense has three more shapes: the name written without the @, the name misspelled, and a link to your domain with no name at all, and all three come from that same search loop. Treat everything as one feed by deduping on tweet ID, and tag each record with the loop that found it, so a report can say how much of the conversation never tagged you at all.

Common search operators for mention tracking

The search loop takes the same operator syntax as X's advanced search, and a handful of operators do nearly all the work in a mention feed.

• "acme corp" and OR to cover the brand name, the product names and the common misspellings in one query.
• -from:acmecorp to drop your own posts, so the feed is the market talking rather than your marketing.
• url:acme.com to catch links to your site from people who never typed your name.
• -filter:retweets so one travelling post counts once rather than hundreds of times.
• lang:en, since: and until: to bound a backfill to one language and one window.

Read a hundred results of any new query by hand before you schedule it. A brand name that is also an everyday word will match strangers all day, and the fix is more exclusions, not a smaller sample.

Competitor keywords and launch tracking

The same two loops point at a competitor with no change but the input. Poll the mentions endpoint for their handle to see who talks to them, and run a search for their brand and product names with their own account excluded to see what the market says about them. Add one query for their name next to complaint words such as slow, outage, pricing or switching. That query is the one sales teams ask for, because it surfaces customers who are unhappy right now.

Launches deserve a temporary feed of their own. When a competitor ships, add a query for the product name and the launch post's link, poll it every five minutes for the first week, then retire it. At 288 calls a day that is about $1.61 for the week, and it gives you the full reaction curve: the first wave of replies, the comparisons people draw, and whether the noise fades or keeps growing.

Set up your feeds by handle and account

Keep the feed list as data rather than code: one row per feed, with the kind (handle or search query), the value, the cadence, and a label for where its results go. A support desk might run its own handle every minute, the founder's handle every five minutes, a brand search every fifteen, and two competitor handles hourly. Adding a feed is then a new row, not a deploy.

Give every feed its own stored anchor, the highest tweet ID it has processed, and share one dedupe store across all of them keyed on tweet ID. The shared store is what stops a post that tags you and names you from arriving twice, once from each loop. With everything in one table, the monthly cost is a sum you can read off the rows: calls per day for each cadence, times thirty, times $0.0008.

Send results to your stack

A mention is only useful where someone will act on it. The response is plain JSON, so the delivery step is a few lines in whatever runs the loop: post a message to a Slack channel, open a ticket in your helpdesk, upsert a row in the CRM keyed on the author's numeric ID, or push the record onto a queue for a classifier. Route by the feed label from your feed table, so support mentions and competitor chatter never land in the same channel.

Send the fields a person needs to act without opening X: the text, the author handle and follower count, the post URL, and the feed that found it. Keep the raw JSON as well, in cheap storage, because the question you will be asked next month is almost always one the summary did not keep the field for.

Reply to a mention from the same key

Answering a mention does not need a second integration. POST /twitter/tweet/create with the reply text and the mention's ID in reply_to posts the answer as the account behind your registered X session, on the same key that runs the loop. It bills $0.0016, and registering the session is a free, one-time call. For replies a person should approve first, save a draft instead with POST /twitter/draft/create: it lands in the account's own composer and is never published by the API. That split, the loop finds and drafts, a person reviews and posts, is the shape that keeps an account's replies sounding like a person rather than a bot.

Push new posts from a handle with a signed webhook

For one event, new posts by a handle you care about, you can stop polling. Register an HTTPS endpoint with POST /twitter/webhook, then start a watch with POST /twitter/monitor. Both calls are free. Each new post is delivered to your endpoint signed with HMAC-SHA256, and the signing secret is returned once, when the webhook is created, so store it then.

Delivery lag and redrive

Two bounds, stated plainly. Our side checks watched handles on a 60-second interval, so a post typically reaches you within a minute of being seen, and GET /twitter/monitor/deliveries reports the measured lag on every delivery. And a failed delivery gets 8 attempts over 21 minutes before it is dead-lettered; if your endpoint was down longer than that, POST /twitter/webhook/{id}/redrive sends the missed events again. Mentions of you are still the polling loop on this page, because the monitor watches what a handle posts, not what others say to it.

Quick integration: from key to first mention in five minutes

There is no developer account to apply for, no OAuth screen, and no app review. Four steps, and the only thing you need before you start is an email address.

1. Get a key. Sign up and the account opens with $0.50 in credits, roughly 625 calls, no card. That is enough to run a one-minute poll for about ten hours before you have decided anything.
2. Make one request by hand. Call the mentions endpoint with a handle you know is busy and read the JSON. Confirm the fields you need are there before you write a line of integration code.
3. Store the anchor. Keep the highest tweet ID in whatever your service already persists, a row, a key in Redis, a file. This is the only state the loop has.
4. Schedule it. A cron entry, a queue worker, or a serverless timer. Nothing about the endpoint requires a long-lived connection, so it runs anywhere that can make an HTTPS request.

If your stack is an agent rather than a service, skip steps three and four: install the MCP server described below and the same endpoint becomes a named tool the model calls directly, on the same key and at the same rate.

Pricing, plain and flat

There is no minimum spend and no monthly seat fee. You start with $0.50 in free credits and pay $0.0008 per call after that. See the full breakdown on the Twitter API pricing page, or explore the full API docs.

X API pricing at a glance

The official X API meters reads per resource: roughly $0.005 to $0.010 for each post read, one post per unit, which is $5 to $10 per 1,000 posts. Here the unit is the call: $0.0008 whatever the call returns, which is $0.04 per 1,000 posts when a call comes back with a full page of 20.

Measured yield per search call

Mention and search calls often come back short of a full page, and the honest comparison uses the measured figure. Per our own billed-call measurement, an average keyword-search call returned 11.44 posts across 484,424 paying read calls from October 22 to 28, 2026 (UTC), which puts a search-shaped workload at about $0.070 per 1,000 posts. That is still over 70 times below the low end of the official per-post rate. The trade a per-call model makes is that a quiet poll which returns nothing still costs one call. The 2026 price sheet lays every tier and alternative side by side.

Filter rules pricing: polling against a stream

X's filtered stream works on filter rules: you register rules and matching posts arrive over a persistent connection, and access to it sits with X's top paid tiers rather than with pay-per-use reads. Here a rule is simply a query string, and there is no stream contract to buy. Every feed in your table is one more polled query, and it costs its cadence: a query polled every five minutes is 8,640 calls a month, about $6.91, whether it matches nothing or hundreds of posts.

That makes the decision about volume and freshness rather than about a plan. Many narrow queries at a relaxed cadence are cheap. A few broad queries that must be seconds fresh are where a push product earns its contract. For the one push this API does offer, new posts from a watched handle, the monitor above is free to set up, and you pay nothing per delivered post.

Real-world cost examples

• Support desk, one handle, every minute. 1,440 calls a day, about 43,200 a month, $34.56. The case where freshness is the product.
• Agency, 20 client handles, every five minutes. 20 times 8,640 is 172,800 calls a month, $138.24, or $6.91 per client, with no per-seat cost for the people reading the output.
• Brand plus three competitor searches, every fifteen minutes. 4 times 2,880 is 11,520 calls a month, about $9.22.
• A 30-day backfill before the loop goes live. One call per page, so a handle with 3,000 mentions in the month is about 150 calls at a full page and closer to 400 at a search-shaped average, $0.12 to $0.32.

The number that moves each bill is cadence, never mention volume. A viral week and a quiet week cost the same to watch at the same interval.

One key, every X endpoint

This is an X API, not a multi-network dashboard, and it goes deep on X instead. The key that runs your mention loop reaches all 121 endpoints in the catalog: replies and quotes under a mention, the author's profile and recent posts for context, follower graphs, lists, communities, and the write calls that answer, like or follow. One balance, one 600-requests-a-minute ceiling and one set of error codes cover all of it, so the context step of a mention workflow, reading the thread and the author before anyone replies, is a few more calls on the same key rather than another vendor. If your brand argues on several networks, treat this as the X input to a wider view and label any X-only figure as X-only.

Wire mentions into an AI agent via MCP

Install the TwitterAPIs MCP server (@twitterapis/mcp) and the mentions endpoint becomes a native tool call any MCP-compatible model can invoke. The same Bearer key authorizes every call, so you add one line to your MCP config and your agent gains a live mention feed with no extra code. For keyword-based search instead of account-based listening, the Twitter search API runs on the same key. To pull an account's full posting history instead of only its mentions, use the Twitter timeline API. To get the follower graph of accounts that mention you, combine with the Twitter followers API, and to resolve the full profile behind each mentioning handle, pass it to the Twitter user API. To widen the same watermarked polling pattern past mentions, onto replies, reposts, follows and DMs, the Twitter account activity API covers every event type, and to aggregate what those mentions earned rather than only list them, the Twitter analytics API carries the metric fields. Need a key? Get a Twitter API key in 30 seconds.