# Twitter Mentions API: Monitor Any Account at $0.04/1K
Canonical: https://www.twitterapis.com/twitter-mentions-api
Description: Twitter mentions API to track every public tweet mentioning an account in near real time. $0.04 per 1,000, polling pattern, no developer account.
Generated: 2026-09-03T18:54:13.299Z
---1.  [Home](/)
2.  / Twitter Mentions API

 MENTIONS

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

## What is the Twitter (X) Mentions API?

The Twitter Mentions API is a REST endpoint that returns every public tweet mentioning any account as paginated JSON at $0.0008 per call ($0.04 per 1,000 results). Poll on a schedule with a `since_id` anchor for near-real-time brand monitoring, support triage, and AI-agent inboxes, on one Bearer key, no developer account, and one flat ceiling of 600 requests a minute per key.

[Start Free](/signup?utm_source=aio&utm_medium=organic&utm_campaign=aeo-twitter-mentions-api)[Read the docs](https://docs.twitterapis.com/docs/reference/user-reads/user-mentions)

## 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.

## What you can build with mentions monitoring

Mentions are the inbound firehose for any public account. The same endpoint and the same Bearer key power every pattern below, billed flat at $0.0008 per call regardless of how many mentions the response contains.

Use case

What to pull

Why it matters

Brand monitoring

Catch every public tweet that tags your handle

React before negative sentiment spreads

Customer support triage

Route inbound @mentions to your helpdesk queue

Faster SLA, no manual tab-watching

Influencer tracking

Log mentions of a partner or competitor handle

Attribution and earned-media measurement

Event listening

Capture mentions of a campaign hashtag account in real time

Live leaderboard or UGC aggregation

AI agent inbox

Feed mentions into an LLM classification pipeline

Auto-tag intent, sentiment, and escalation priority

For tweet-level search by keyword or hashtag rather than account handle, use the [Twitter search API](/twitter-search-api). Mentions and search share the same key and the same flat billing. The query syntax that narrows a keyword pull, from:, to:, min\_faves:, since: and the rest, is documented in the [Twitter advanced search operators guide](/blogs/twitter-advanced-search-operators).

## 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

curlPythonJavaScript

Copy

```
# 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](https://docs.twitterapis.com/docs/reference/user-reads/user-mentions).

## Polling interval vs cost: pick your cadence

Every poll is one call at $0.0008, regardless of how many mentions the response contains. The only cost lever is how often you poll. Match your interval to the freshness your use case actually requires.

Poll interval

Calls / day

Calls / month

Cost / month

Best for

Every 60 s

1,440

~43,200

~$34.56

Near-real-time support queues, high-volume brand accounts

Every 5 min

288

~8,640

~$6.91

Moderate brand monitoring, competitor tracking

Every 15 min

96

~2,880

~$2.30

Low-volume accounts, research ingestion pipelines

Every 1 hour

24

~720

~$0.58

Periodic audits, daily digest aggregators

Monitoring multiple accounts multiplies costs by the number of handles. See the full breakdown on the [Twitter API pricing page](/twitter-api-pricing).

## TwitterAPIs mentions vs the official X API and manual watching

Option

Price

Auth

Limits

Near-real-time

TwitterAPIs

$0.04 / 1,000 mentions

Bearer token, 30 s signup

600 req/min per key

Poll every 60 s

Official X API user/mentions

Gated, paid enterprise tier

X developer account, app approval

Hard request caps on every tier

Streaming only on enterprise

Manual browser monitoring

$0 plus your time

None

Manual, misses fast threads

Not real time

## 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.

First call, then the incremental one

Copy

```
# 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.

Brand terms without the @

Copy

```
# 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

$0.04

per 1,000 mentions returned

$0.50

free credits at signup, no card

$0

subscription, you pay per call only

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](/twitter-api-pricing), or explore the full [API docs](https://docs.twitterapis.com/docs).

## Wire mentions into an AI agent via MCP

Install the [TwitterAPIs MCP server](/mcp) (`@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](/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](/twitter-timeline-api). To get the follower graph of accounts that mention you, combine with the [Twitter followers API](/twitter-followers-api), and to resolve the full profile behind each mentioning handle, pass it to the [Twitter user API](/twitter-user-api). To widen the same watermarked polling pattern past mentions, onto replies, reposts, follows and DMs, the [Twitter account activity API](/twitter-account-activity-api) covers every event type, and to aggregate what those mentions earned rather than only list them, the [Twitter analytics API](/twitter-analytics-api) carries the metric fields. Need a key? [Get a Twitter API key in 30 seconds](/twitter-api-key).

## Twitter mentions API FAQ

### What does the Twitter mentions API return?

GET /twitter/user/mentions returns a paginated array of public tweets that mention the given account. Each tweet object includes the full tweet text, author details, timestamp, public metrics (likes, retweets, replies, views), conversation ID, and whether the tweet is a reply or a quote. The response also carries a next\_cursor and has\_more flag so you can walk multiple pages of older mentions, and a since\_id anchor so each polling cycle only returns new tweets since the last call.

### How much does it cost to monitor mentions with the API?

Each call is $0.0008 (source: twitterapis pricing). If you poll once per minute around the clock that is 1,440 calls per day, or about 43,200 per month, which works out to $34.56 per month. Polling every 5 minutes drops that to $6.91 per month. There is no subscription, no monthly minimum, and you start with $0.50 in free credits at signup. The official X API gates user mentions lookup behind paid developer tiers with hard request caps; TwitterAPIs charges only for what you actually pull.

### What is the since\_id parameter and why should I use it?

since\_id is a tweet ID string you pass on every polling call after the first. The API returns only mentions posted after that tweet ID, so your pipeline is incremental: each cycle you pull exactly the new mentions and nothing you already processed. Without it every poll returns the full recent history and you have to de-duplicate on your side. Store the highest ID you see after each call and pass it as since\_id on the next one.

### How do I wire Twitter mentions into an AI agent or MCP server?

Install the TwitterAPIs MCP package (@twitterapis/mcp) and add your Bearer token to your MCP config. The MCP server exposes user/mentions as a native tool call, so Claude, GPT, or any MCP-compatible model can fetch a live mention feed in a tool turn with no extra code. For custom agent stacks, call the REST endpoint directly from a tool-use handler and pass the result to your LLM classification step.

### How do I poll for new mentions in near real time?

Call GET /twitter/user/mentions with the userName you want to monitor and store the highest tweet ID you see. On every subsequent call, pass that ID as the since\_id parameter. The API returns only tweets posted after that ID, so each poll is incremental and you never re-process a mention. Call every 60 seconds for near-real-time coverage ($0.0008 per call, about $34.56 per month at that cadence) or every 5 minutes for moderate monitoring ($6.91 per month).

### Do I need an X developer account or API key from X?

No. You do not need an X developer account or any OAuth setup. You need only a TwitterAPIs key, which is a single Bearer token you copy after a 30-second signup. No app review, no waiting period, no X approval. You can start pulling mentions within a minute of registering.

### Can I paginate through historical mentions?

Yes. Omit since\_id and use the cursor pagination instead. Each response includes a next\_cursor and a has\_more flag. Pass next\_cursor back on the next call to walk backwards through older mentions. Use cursor pagination for historical backfills (auditing the last 30 days of mentions, for example), and switch to since\_id polling for the live monitoring loop once you have ingested the history.

### Monitor mentions without an X account

$0.04 per 1,000 mentions. $0.50 free credits. since\_id polling, no developer account, 600 req/min per key.

[Start Free](/signup?utm_source=aio&utm_medium=organic&utm_campaign=aeo-twitter-mentions-api)[View Pricing](/twitter-api-pricing?utm_source=aio&utm_medium=organic&utm_campaign=aeo-twitter-mentions-api)

## Next read

Continue exploring related pages:

[

Twitter API use cases

14 use cases from sentiment analysis to lead generation.

](/twitter-api-usecases)[

Twitter API answers

Short, sourced answers to the most common Twitter and X API questions.

](/answers)[

Twitter timeline API

Pull an account's full posting history over one REST endpoint.

](/twitter-timeline-api)[

Twitter list API

Read list members and list timelines with the same Bearer key.

](/twitter-list-api)

[View API Docs](https://docs.twitterapis.com/docs/reference/user-reads/user-mentions)[Start Free](/signup?utm_source=aio&utm_medium=organic&utm_campaign=aeo-twitter-mentions-api)

[

TwitterAPIs ](/)

The cheapest pay-as-you-go Twitter and X API. $0.0008 per call, which works out to $0.04 per 1,000 tweets on a full 20-tweet page. No subscriptions and no developer account.

## Product / API

-   [Pricing](/pricing)
-   [Pay-Per-Use Pricing](/pay-per-use-pricing)
-   [Cost Calculator](/twitter-api-cost-calculator)
-   [Rate Limits](/twitter-api-rate-limits)
-   [MCP Server](/mcp)
-   [Integrations](/integrations)
-   [Language Clients](/sdk)
-   [Changelog](/changelog)
-   [Status](/status)

## Developers

-   [Documentation](https://docs.twitterapis.com)
-   [API Reference](https://docs.twitterapis.com/docs/reference/search/tweet-advanced-search)
-   [User Info](https://docs.twitterapis.com/docs/reference/user-reads/user-info)
-   [User Tweets](https://docs.twitterapis.com/docs/reference/user-reads/user-tweets)
-   [Advanced Search](https://docs.twitterapis.com/docs/reference/search/tweet-advanced-search)
-   [Verified Followers](https://docs.twitterapis.com/docs/reference/follower-graph/user-verified-followers)

## Resources / Compare

-   [Answers](/answers)
-   [Reviews](/reviews)
-   [Free Tools](/tools)
-   [Twitter ID Finder](/tools/twitter-id-finder)
-   [Get a Twitter API Key](/twitter-api-key)
-   [Official X API Comparison](/twitter-api-pricing)
-   [Twitter API Use Cases](/twitter-api-usecases)
-   [Twitter API Alternatives](/twitter-api-alternatives)
-   [Twitter Unofficial API](/twitter-unofficial-api)
-   [Twitter Free API](/twitter-free-api)
-   [TwitterAPIs vs twitterapi.io](/twitterapis-vs-twitterapi-io)
-   [TwitterAPIs vs GetXAPI](/twitterapis-vs-getxapi)
-   [TwitterAPIs vs TweetAPI](/twitterapis-vs-tweetapi)
-   [TwitterAPIs vs TwexAPI](/twitterapis-vs-twexapi)
-   [TwitterAPIs vs RapidAPI](/twitterapis-vs-rapidapi)

## Legal

-   [About](/about)
-   [Security](/security)
-   [Trust](/privacy-and-data-handling)
-   [Terms of Service](/terms-of-service)
-   [Affiliates](/affiliates)
-   [Contact](/contact)
-   [Jobs](/jobs)

© 2026 TwitterAPIs. All rights reserved.

TwitterAPIs is an independent third-party API for developers and researchers. Not affiliated with, endorsed by, or sponsored by X Corp.

All systems operational