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, plus a since_id anchor you store to make every subsequent poll incremental. Cost: $0.0008 per call, or about $0.04 per 1,000 mentions pulled. No X developer account required.

Pull mentions with a since_id polling loop

The mentions endpoint lives at GET /twitter/user/mentions. On the first call, omit since_id to get the most recent mentions. Store the highest tweet ID you see. On every subsequent call, pass that stored ID as since_id and the API returns only tweets posted after it, keeping each poll incremental and cost-efficient.

First pull + ongoing polling loop

# First pull: latest mentions of @yourhandle
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/mentions?userName=yourhandle"

# Subsequent calls: only new mentions since tweet ID 1800000000000000000
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/mentions?userName=yourhandle&since_id=1800000000000000000"

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. First call has no anchor and returns a page of recent mentions. You record the highest tweet ID you saw. Every call after that passes it as since_id, so the API returns only what arrived since, and a quiet minute returns an empty array for $0.0008 rather than the same twenty tweets again.

# 1. Cold start. No since_id, so this is the current page.
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/mentions?userName=jack"

# -> { "tweets": [ ... ], "count": 20,
#      "next_cursor": "...", "has_more": true }

# 2. Record the highest id you saw, then poll with it.
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/mentions?userName=jack&since_id=1799342211110000000"

# -> { "tweets": [ 2 new items ], "count": 2, "has_more": false }
# Two new mentions, one call, $0.0008. A quiet cycle returns
# an empty array at the same price.

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 it is false 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.

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.

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.