This MCP server provides programmatic access to Twitter/X data and actions through 40 tools (29 reads + 11 writes), enabling AI agents to search, retrieve, and manage tweets, user profiles, and direct messages.
Search & Discovery
Advanced tweet search using X operators (from:, min_faves:, since:, filter:links, etc.) with ranking modes (Top, Latest, Media, People)
User account search by name, keyword, or topic
User Profiles & Relationships
Get full user profiles by handle (twitter_user_info) or numeric ID (twitter_user_info_by_id)
Get structured About panel data (category, professional labels, joined date)
List affiliated accounts of an organization profile
Check follow relationships between two users
List followers and following (standard and v2 variants), verified followers only, and mutual followers ("Followers you know")
Tweets & Timelines
Get a user's original tweets, full activity timeline (tweets + replies), complete tweet history (auto-paginated), media posts, mentions, and liked tweets
Fetch single tweet details, replies, full threads, and retweeters
View your home timeline (requires authenticated session)
Lists, Bookmarks & DMs (session required)
List members of a Twitter/X List by list ID
View and search your bookmarks
List DM conversations and read messages within a specific conversation
Write Actions (require authenticated session)
Post new tweets (including replies and quote-tweets), delete your own tweets
Like/unlike, retweet/unretweet, bookmark/unbookmark tweets
Follow/unfollow users by numeric ID
Send Direct Messages
Key Features
Requires an API key (TWITTERAPIS_KEY) for all operations
Supports pagination via cursors for all list-type endpoints
Supports per-call inline credentials (auth_token + ct0) to act as different accounts under a single API key
Supports proxy_url for write actions to avoid datacenter IP soft-blocks
Some endpoints (e.g., twitter_user_likes, twitter_user_tweets_complete) strictly require user_id rather than username
Destructive actions (delete tweet, unfollow, etc.) are annotated with destructiveHint: true so MCP clients can prompt before executing
Provides Windsurf (by Codeium) with tools to access Twitter/X data such as tweets, user info, lists, and advanced search.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@twitterapis get the last 5 tweets from @openai"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Official Model Context Protocol server for twitterapis.com, the Twitter / X API as native tools for Claude, Cursor, Windsurf, and any MCP client. Reads (search, profiles, timelines, followers, DMs) plus write actions (post, like, retweet, follow).
Ask your agent to search tweets, pull a user's profile or timeline, list followers/following, fetch thread context, or enumerate list members and it calls the API directly. Every tool maps to a REST endpoint at https://api.twitterapis.com; the server holds no state and forwards your API key on each call.
No install needed. Run with npx. You need one thing: an API key (free $0.50 in credits, no card required): twitterapis.com/signup.
Related MCP server: Twitter MCP
Edit claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"twitterapis": {
"command": "npx",
"args": ["-y", "@twitterapis/mcp@latest"],
"env": { "TWITTERAPIS_KEY": "YOUR_API_KEY" }
}
}
}Restart Claude Desktop. The twitter_* tools appear in the tool picker.
~/.cursor/mcp.json (or Settings → MCP → Add New Server):
{
"mcpServers": {
"twitterapis": {
"command": "npx",
"args": ["-y", "@twitterapis/mcp@latest"],
"env": { "TWITTERAPIS_KEY": "YOUR_API_KEY" }
}
}
}~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"twitterapis": {
"command": "npx",
"args": ["-y", "@twitterapis/mcp@latest"],
"env": { "TWITTERAPIS_KEY": "YOUR_API_KEY" }
}
}
}.vscode/mcp.json in your workspace, or the user-level MCP settings:
{
"servers": {
"twitterapis": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@twitterapis/mcp@latest"],
"env": { "TWITTERAPIS_KEY": "YOUR_API_KEY" }
}
}
}Env var | Required | Default | Purpose |
| Yes | (none) | API key from dashboard |
| No |
| Override the API host |
| No |
| Per-request timeout in milliseconds |
94 tools: 60 reads and 34 write actions. Most user endpoints accept username (handle without @) or user_id (twitter_user_likes and twitter_user_tweets_complete require user_id); tweet endpoints accept id or url; paginated endpoints return a cursor you pass back to get the next page. Two of the reads are free account/billing lookups (twitter_account_me, twitter_account_payments); the 14 monitoring tools are also free (account administration, not metered reads).
Public reads (search, profiles, tweets, followers, likes) work with just your API key. The account-only reads (bookmarks, DMs, home timeline, followers-you-know) and most write actions act AS an authenticated X account, so they need a session linked to your key first (returns HTTP 409 until then). Link a session either by registering your x.com cookies (twitter_customer_session) or by logging in with a username/password (twitter_user_login). Alternatively, pass per-call inline credentials on any of those tools (auth_token + ct0, with optional proxy_url / user_agent) to act AS that account for a single call without pre-registering a session, so one API key can act as many accounts. For write actions, set proxy_url to a residential proxy, since X soft-blocks writes that egress from datacenter IPs. Each write tool is annotated readOnlyHint: false; reversing actions (delete, unfollow, unlike, unretweet, unbookmark, monitor/webhook delete) are annotated destructiveHint: true so MCP clients can prompt before running them. The monitoring tools (see below) are the one exception: they administer your twitterapis.com account, not an X session, so they need only your API key, no linked session and no inline credentials.
Tool | What it does |
| Search tweets with X operators ( |
| Find user accounts by name or keyword |
| Full profile by handle (bio, counts, verification, location) |
| Full profile by numeric user id |
| Is an account alive, suspended, or deleted |
| A user's structured About object (category, professional/business labels, verification + identity-verification flags, joined date, and X's 'About this account' transparency panel) |
| Accounts affiliated with an organization profile |
| Follow relationship between two user ids (who follows whom) |
| A user's recent original tweets (replies excluded) |
| A user's full timeline (tweets + replies) |
| A user's near-complete tweet history in one auto-paginated call |
| Images and videos a user has posted |
| Recent public tweets mentioning a user |
| Tweets a user has liked (public Likes tab) |
| Accounts that follow a user |
| Accounts a user follows |
| Followers with the v2 response shape (richer fields, deeper cursoring) |
| Following with the v2 response shape (richer fields, deeper cursoring) |
| A user's verified followers only |
| Followers of a target that your authenticated account also follows |
| Single tweet: text, author, metrics, media, quoted/reply context |
| Replies to a tweet |
| Full author thread (connected tweet chain by same author) |
| Accounts that retweeted a tweet |
| Tweets that quote a tweet, with their text. Search-backed, so |
| Members of a Twitter/X List |
| Accounts that follow a public List (a different set from its members) |
| Posts by a List's members, search-backed: filterable by |
| A List's native X feed: retweets and X's own ordering included, no filters, paging only |
| Your authenticated account's Home timeline (session) |
| Your authenticated account's bookmarks (session) |
| Accounts your authenticated account has blocked (your own list only) (session) |
| Accounts your authenticated account has muted (your own list only) (session) |
| Full-text search within your bookmarks (session) |
| Your authenticated account's bookmark folders (session) |
| Tweets inside one of your bookmark folders, by |
| Your DM conversations (inbox), read-only (session) |
| Messages in one DM conversation, read-only (session) |
| Metadata and participant roster for one X Space, live or ended (by Space |
| Find X Communities by keyword; the discovery step that produces the numeric id the rest of the community family needs |
| One X Community by numeric id: name, counts, join policy, rules, topic, banners, admin |
| A community's moderators and a member preview, each returned as a full user profile, not the reduced row |
| A community's member roster, each row carrying that member's |
| A community's moderators and admins, from its own upstream operation (not a filter over the roster) |
| A community's post timeline, with the pinned post returned as its own |
| The inverse lookup: every community a given numeric |
| Ask X's own Grok, grounded in live X data, and get the answer plus the sources it cited |
| Whether the authenticated account can use Grok, and which models it may pick |
| Current top trends for a location (by |
| Every location X has trends for, each with its WOEID |
| Your twitterapis.com account: credits, usage, email (free) |
| Your twitterapis.com payment history (free) |
| Processing state of an uploaded |
| Read a published article's full content via its announcement tweet id/url (public, no session) |
| List your own articles, filtered by |
Tool | What it does |
| Post a tweet; set |
| Delete one of your tweets (irreversible) |
| Like / unlike a tweet |
| Retweet / undo retweet |
| Bookmark / remove bookmark |
| Follow / unfollow a user by id |
| Send a Direct Message to a user by their numeric |
| Create a Twitter/X List owned by your session ( |
| Add / remove one account on a List you own; |
| Upload a base64 image, returns a |
Tool | What it does |
| Start a new draft article, returns its |
| Set a draft or published article's title |
| Attach an already-uploaded image as an article's cover ( |
| Replace a draft or published article's body (Draft.js |
| Publish a draft, posting a real public announcement tweet (not fully reversible) |
| Revert a published article to draft (leaves the announcement tweet up) |
| Delete an article (draft: hard delete; published: unpublish + delete the announcement tweet), irreversible |
See also twitter_article_get and twitter_article_list above.
Watch an X account for new posts and get them pushed to your own HTTPS endpoint, HMAC-signed, instead of polling. Register a webhook first, then create a monitor; every new post from a watched handle is delivered to every active webhook on your account (or a restricted subset via webhook_ids). Monitor/webhook CRUD is account administration, not a metered Twitter read, so every tool below is free.
Tool | What it does |
| Start watching an X account ( |
| List every monitor on your account |
| Pause/resume a monitor or change its |
| Stop and remove a monitor (irreversible) |
| One monitor's status, degradation flag, poll interval, cursor position |
| Account-wide rollup: service status, active/paused monitor counts, 24h delivery outcome counts, one call |
| Recent delivery events across every monitor, with detection + delivery latency |
| Compat drop-in for |
| Compat drop-in for |
| Compat drop-in for |
| Register an HTTPS delivery URL; returns the HMAC signing secret once |
| List every webhook registered on your account |
| Soft-delete a webhook by id (irreversible from the caller's side) |
| Send one signed test event to a webhook right now, synchronously |
Link an X account to your key once, so the account-only reads and write actions act as it (or pass per-call auth_token/ct0 instead).
Tool | What it does |
| Register your x.com session cookies ( |
| Revoke that stored session, deleting your |
| Log in with |
"Find the most popular tweets about AI agents posted this week"
The agent calls twitter_advanced_search with:
query: "AI agents min_faves:200 since:2024-01-01"
product: "Top"
count: 20"Get the last 10 tweets from @sama"
The agent calls twitter_user_tweets with:
username: "sama"
count: 10"Get the full thread for this tweet: https://x.com/karpathy/status/1849....."
The agent calls twitter_tweet_thread with:
url: "https://x.com/karpathy/status/1849.....""List the first 100 followers of @openai, then the next 100"
First call, twitter_user_followers: { username: "openai", count: 100 }
Second call, pass back the cursor from the first response: { username: "openai", count: 100, cursor: "<cursor from response>" }
"Show me recent tweets mentioning @twitterapis"
The agent calls twitter_user_mentions with:
username: "twitterapis"
count: 50HTTP 401 (invalid or missing API key) Check that TWITTERAPIS_KEY is set correctly in your MCP client config and matches the key shown in your dashboard.
HTTP 402 (insufficient credits) Top up at twitterapis.com/dashboard. Your first $0.50 is free at signup.
HTTP 403 (access forbidden) The account or tweet may be private/protected, or your plan does not include this endpoint.
HTTP 404 (not found) The user, tweet, or list may have been deleted, suspended, or the id/handle is wrong.
HTTP 429 (rate limited) Wait a few seconds and retry. If you hit this frequently, add "TWITTERAPIS_TIMEOUT_MS": "60000" to your env config and space out bulk requests.
Request failed: timed out after 30000ms The default timeout is 30 s. For large paginated fetches set TWITTERAPIS_TIMEOUT_MS to a higher value (e.g. 60000).
Tools do not appear in Claude / Cursor Ensure npx is on your PATH and Node.js 18+ is installed (node --version). Check MCP client logs for startup errors.
Calls are billed to your twitterapis.com account. Almost every endpoint is $0.0008/call: all reads (search, profiles, tweets, followers, likes) plus the simple write actions (like, retweet, bookmark, follow and their undos, delete). At the read rate that works out to $0.04 per 1,000 tweets, since each call returns about 20 tweets. The premium endpoints cost a little more: tweet creation, sending a DM (twitter_dm_send), and DM reads (twitter_dm_list, twitter_dm_conversation) at $0.0016/call, full tweet history (twitter_user_tweets_complete) at $0.0024/call, a full tweet thread (twitter_tweet_thread) and a Grok answer (twitter_grok_chat) at $0.004/call, and the article-editing writes (twitter_article_create, twitter_article_update_title, twitter_article_update_cover_media, twitter_article_update_content, twitter_article_publish, twitter_article_unpublish) at $0.0016/call (twitter_article_get, twitter_article_list, and twitter_article_delete stay at the standard $0.0008/call). Your first $0.50 is free. See twitterapis.com/pricing.
Docs: docs.twitterapis.com
Dashboard / API keys: twitterapis.com/dashboard
Pricing: twitterapis.com/pricing
REST API base URL (call it directly, without MCP): https://api.twitterapis.com
Do I need an X (Twitter) developer account? No. Get an API key at twitterapis.com/signup; there is no application or approval step.
Is it read-only? No. 60 read tools work with just your API key; 34 write actions (post, like, retweet, follow, DM, media upload, List create/add member/remove member, article create/edit/publish/delete, monitor/webhook create/update/delete) act as a linked X account or per-call inline credentials, except monitor/webhook CRUD, which is account administration and needs only your API key.
Which clients are supported? Claude Desktop, Cursor, Windsurf, and VS Code (Copilot agent mode), or any Model Context Protocol client.
How is it billed? Per request. New keys start with $0.50 in free credits, no card required. See pricing.
Does it store my key or data? No. The server holds no state and forwards your API key on each call.
src/tools.js is generated. Do not edit it. The catalog is built at build time from two committed inputs:
test/openapi.snapshot.json, a vendored copy of the published OpenAPI spec, which supplies the structure: which endpoints exist, which parameters each accepts, whether a parameter is required, and its type.
scripts/tools.overrides.mjs, hand-authored, which supplies everything the spec cannot express: the tool and argument descriptions a model reads to decide how to call a tool, the cross-field rules ("provide exactly one of username or user_id"), the per-call credential arguments that travel as x-* headers, and the write / destructive / JSON-body flags.
The spec is vendored on purpose. Nothing is fetched at install time or at server boot, so the published package is a fixed artifact rather than one that depends on a hostname still answering.
npm run openapi:refresh # re-vendor the spec, prints the route diff
npm run build # regenerate src/tools.js
npm test # gates, incl. "src/tools.js matches the generator"npm test fails if src/tools.js was hand-edited or left stale, if the catalog and the live spec disagree, or if the tool list and this README disagree.
MIT
FastMCP server for posting formatted content to X (Twitter) — Tollbooth-monetized, DPYC-native
Hosted MCP for X/Twitter and Reddit. 12 read-only tools, no API keys, free during beta.
128 REST operations. 120 MCP routes; 119 JSON/text ops. OAuth 2.1. Not affiliated with X Corp.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/TwitterAPIs/twitterapis-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server