Which integrations are available for this server?

Supports deployment as a Docker container with cross-platform publishing for multiple architectures (linux/amd64, linux/arm64, linux/arm/v7).

How do I use MCP Server - Twitter NoAuth?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Server - Twitter NoAuth search for tweets about AI developments from the past week" 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.

en es ja ko zh

MCP Server - Twitter NoAuth

by baryhuang

Overview Schema Related Servers Score Discussions

Python

Remote

MCP Server - Twitter NoAuth

A MCP (Model Context Protocol) server that provides Twitter API access without local credential or token setup. Provides core Twitter operations like searching tweets, getting user tweets, posting tweets, and replying to tweets.

Demo Video

https://www.youtube.com/watch?v=LOxFqCTPedc

Related MCP server: TwitterAPI MCP Server

Why MCP Twitter NoAuth Server?

Critical Advantages

Headless & Remote Operation: This server can run completely headless in remote environments with no browser and no local file access.
Decoupled Architecture: Any client can complete the OAuth flow independently, then pass credentials as context to this MCP server, creating a complete separation between credential storage and server implementation.

Nice but not critical

Focused Functionality: Provides core Twitter operations like searching tweets, getting user tweets, posting tweets, and replying to tweets.
Docker-Ready: Designed with containerization in mind for a well-isolated, environment-independent, one-click setup.
Reliable Dependencies: Built on standard Python requests library for Twitter API integration.

Features

Search tweets using Twitter API
Get recent tweets by a specific user
Get recent replies by a specific user
Post new tweets
Reply to existing tweets
Refresh access tokens separately
Automatic refresh token handling

Prerequisites

Python 3.10 or higher
Twitter API credentials (client ID, client secret, access token, and refresh token)

Installation

# Clone the repository
git clone https://github.com/yourusername/mcp-twitter-noauth.git
cd mcp-twitter-noauth

# Install dependencies
pip install -e .

Docker

Building the Docker Image

# Build the Docker image
docker build -t mcp-twitter-noauth .

Usage with Claude Desktop

Docker Usage

You can configure Claude Desktop to use the Docker image by adding the following to your Claude configuration:

{
  "mcpServers": {
    "twitter": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "buryhuang/mcp-twitter-noauth:latest"
      ]
    }
  }
}

Note: With this configuration, you'll need to provide your Twitter API credentials in the tool calls as shown in the Using the Tools section. Twitter credentials are not passed as environment variables to maintain separation between credential storage and server implementation.

Cross-Platform Publishing

To publish the Docker image for multiple platforms, you can use the docker buildx command. Follow these steps:

Create a new builder instance (if you haven't already):
```
docker buildx create --use
```

Build and push the image for multiple platforms:

docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t buryhuang/mcp-twitter-noauth:latest --push .

Verify the image is available for the specified platforms:

docker buildx imagetools inspect buryhuang/mcp-twitter-noauth:latest

Usage

The server provides Twitter functionality through MCP tools. Authentication handling is simplified with a dedicated token refresh tool.

Starting the Server

mcp-server-twitter-noauth

Using the Tools

When using an MCP client like Claude, you have two main ways to handle authentication:

Refreshing Tokens (First Step or When Tokens Expire)

If you have both access and refresh tokens:

{
  "twitter_access_token": "your_access_token",
  "twitter_refresh_token": "your_refresh_token",
  "twitter_client_id": "your_client_id",
  "twitter_client_secret": "your_client_secret"
}

If your access token has expired, you can refresh with just the refresh token:

{
  "twitter_refresh_token": "your_refresh_token",
  "twitter_client_id": "your_client_id",
  "twitter_client_secret": "your_client_secret"
}

This will return a new access token and its expiration time, which you can use for subsequent calls.

Searching Tweets

Search for tweets using the Twitter API:

{
  "twitter_access_token": "your_access_token",
  "query": "your search query",
  "max_results": 10
}

Response includes tweet data including text, creation time, and author information.

Getting User Tweets

Get recent tweets by a specific user:

{
  "twitter_access_token": "your_access_token",
  "user_id": "twitter_user_id",
  "max_results": 10
}

Getting User Replies

Get recent replies by a specific user:

{
  "twitter_access_token": "your_access_token",
  "user_id": "twitter_user_id",
  "max_results": 10
}

Posting a Tweet

Post a new tweet:

{
  "twitter_access_token": "your_access_token",
  "text": "This is a test tweet from the MCP Twitter server"
}

Replying to a Tweet

Reply to an existing tweet:

{
  "twitter_access_token": "your_access_token",
  "tweet_id": "id_of_tweet_to_reply_to",
  "text": "This is a reply to the original tweet"
}

Token Refresh Workflow

Start by calling the twitter_refresh_token tool with either:
- Your full credentials (access token, refresh token, client ID, and client secret), or
- Just your refresh token, client ID, and client secret if the access token has expired
Use the returned new access token for subsequent API calls.
If you get a response indicating token expiration, call the twitter_refresh_token tool again to get a new token.

This approach simplifies most API calls by not requiring client credentials for every operation, while still enabling token refresh when needed.

Obtaining Twitter API Credentials

To obtain the required Twitter API credentials, follow these steps:

Go to the Twitter Developer Portal
Create a new project and app
Set up OAuth 2.0 authentication
Configure the OAuth settings for your app
Generate client ID and client secret
Complete the OAuth flow to obtain access and refresh tokens

Token Refreshing

This server implements automatic token refreshing. When your access token expires, the server will use the refresh token, client ID, and client secret to obtain a new access token without requiring user intervention.

Security Note

This server requires direct access to your Twitter API credentials. Always keep your tokens and credentials secure and never share them with untrusted parties.

License

See the LICENSE file for details.

Available Tools

6 tools

twitter_get_user_repliesC

Get recent replies by a specific user

ParametersJSON Schema

Name	Required	Description
`max_results`	No	Maximum number of tweets to return (default: 10)
`twitter_access_token`	Yes	Twitter OAuth2 access token
`user_id`	No	Twitter user ID (optional if username is provided)
`username`	No	Twitter username/handle (optional if user_id is provided)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Get recent replies') but lacks details on rate limits, authentication requirements (beyond the required parameter), pagination, error handling, or what 'recent' means (e.g., time frame). This leaves significant gaps for an AI agent to understand how to use it effectively.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse. Every word earns its place by conveying essential information without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (fetching user replies from an API), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like rate limits or authentication needs, nor does it hint at the return format (e.g., tweet objects, error responses). This leaves the AI agent with insufficient context for reliable use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, so the schema already documents all four parameters thoroughly. The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't clarify the relationship between 'user_id' and 'username' or explain 'recent' in context of 'max_results'). Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Get recent replies by a specific user' clearly states the verb ('Get') and resource ('replies by a specific user'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'twitter_get_user_tweets' or 'twitter_reply_to_tweet' beyond the 'replies' keyword, which is why it doesn't reach a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'twitter_get_user_tweets' (which might fetch all tweets including replies) or 'twitter_search_tweets' (which could search for replies), nor does it specify any prerequisites or exclusions beyond what's implied by the parameters.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

twitter_get_user_tweetsC

Get recent tweets by a specific user

ParametersJSON Schema

Name	Required	Description
`max_results`	No	Maximum number of tweets to return (default: 10)
`twitter_access_token`	Yes	Twitter OAuth2 access token
`user_id`	No	Twitter user ID (optional if username is provided)
`username`	No	Twitter username/handle (optional if user_id is provided)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but offers minimal behavioral context. It doesn't disclose rate limits, pagination, error handling, or what 'recent' means (e.g., time range). The mention of 'recent' is vague and lacks operational details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly without unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 4 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on authentication requirements (beyond schema), return format, error cases, and behavioral constraints like rate limits, leaving significant gaps for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional meaning beyond implying user-specific retrieval, which is already clear from the tool name and schema. Baseline 3 is appropriate as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and resource 'recent tweets by a specific user', making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'twitter_get_user_replies' or 'twitter_search_tweets', which would require more specificity about scope or filtering.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'twitter_get_user_replies' for replies or 'twitter_search_tweets' for broader searches, nor does it specify prerequisites beyond the implied authentication.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

twitter_post_tweetC

Post a new tweet

ParametersJSON Schema

Name	Required	Description	Default
`text`	Yes	The tweet text content
`twitter_access_token`	Yes	Twitter OAuth2 access token

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Post a new tweet' implies a write operation, but it doesn't disclose critical traits such as rate limits, authentication requirements (beyond what's in the schema), potential side effects (e.g., tweet visibility), or error handling. The description is minimal and lacks necessary context for safe and effective use.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description 'Post a new tweet' is extremely concise—a single, front-loaded sentence with zero wasted words. It efficiently communicates the core action without unnecessary elaboration, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a write operation (posting a tweet) with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects like authentication needs, rate limits, or what the tool returns (e.g., tweet ID or success status). For a mutation tool, this leaves significant gaps in understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with clear documentation for both parameters ('text' and 'twitter_access_token'). The description adds no additional meaning beyond what the schema provides, such as format details or constraints. Baseline score of 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Post a new tweet' clearly states the action (post) and resource (tweet), making the purpose immediately understandable. It distinguishes from siblings like 'twitter_reply_to_tweet' by specifying a new tweet rather than a reply, though it doesn't explicitly contrast with other siblings like 'twitter_search_tweets'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing authentication via twitter_access_token), exclusions, or comparisons to siblings like 'twitter_reply_to_tweet' for replying or 'twitter_get_user_tweets' for reading. Usage is implied but not explicitly stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

twitter_refresh_tokenC

Refresh the access token using the refresh token and client credentials

ParametersJSON Schema

Name	Required	Description
`twitter_access_token`	No	Twitter OAuth2 access token (optional if expired)
`twitter_client_id`	Yes	Twitter OAuth2 client ID for token refresh
`twitter_client_secret`	No	Twitter OAuth2 client secret (required only for confidential clients)
`twitter_refresh_token`	Yes	Twitter OAuth2 refresh token

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It mentions using 'refresh token and client credentials' but doesn't disclose behavioral traits like whether this invalidates old tokens, requires specific permissions, has rate limits, or what the output looks like (no output schema). For a security-sensitive tool, this is inadequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core action ('Refresh the access token') without unnecessary words. Every part earns its place by specifying the method and resources used.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of OAuth2 token refresh, no annotations, and no output schema, the description is incomplete. It lacks details on authentication flow, error handling, or return values, leaving significant gaps for the agent to operate safely and effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds minimal value beyond the schema by implying the purpose of refresh but doesn't provide additional context like parameter interactions or edge cases. Baseline 3 is appropriate as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Refresh') and the resource ('access token'), specifying it uses 'refresh token and client credentials'. It distinguishes from siblings like posting or searching tweets by focusing on authentication renewal. However, it doesn't explicitly contrast with other auth-related tools (none listed), so it's not a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives is provided. The description implies it's for refreshing tokens but doesn't specify prerequisites (e.g., when access token expires), exclusions, or how it relates to initial authentication. With no annotations, this leaves the agent guessing about context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

twitter_reply_to_tweetC

Reply to an existing tweet

ParametersJSON Schema

Name	Required	Description
`text`	Yes	The reply text content
`tweet_id`	Yes	ID of the tweet to reply to
`twitter_access_token`	Yes	Twitter OAuth2 access token

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Reply to' implies a write/mutation operation, the description doesn't disclose critical behavioral traits such as authentication requirements (implied by the access token parameter but not stated), rate limits, whether replies are public/private, or what happens on success/failure. For a mutation tool with zero annotation coverage, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise with a single sentence ('Reply to an existing tweet') that efficiently conveys the core purpose. It's front-loaded with no wasted words, making it easy to parse quickly. Every word earns its place, though this conciseness comes at the cost of completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a social media write operation with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., success confirmation, reply ID, error details), behavioral aspects like rate limits or permissions, or how it differs from sibling tools. For a 3-parameter mutation tool, this minimal description leaves too many gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds no parameter semantics beyond what the input schema provides. The schema has 100% description coverage with clear explanations for 'text', 'tweet_id', and 'twitter_access_token'. Since schema coverage is high (>80%), the baseline score is 3, as the description doesn't compensate with additional context like format examples or constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Reply to') and the resource ('an existing tweet'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'twitter_post_tweet' (which presumably posts original tweets) or 'twitter_get_user_replies' (which retrieves replies). The description is specific but lacks sibling distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'twitter_reply_to_tweet' over 'twitter_post_tweet' for posting content, nor does it indicate prerequisites like needing an access token or a valid tweet ID. There's no explicit when/when-not usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

twitter_search_tweetsC

Search for tweets using the Twitter API

ParametersJSON Schema

Name	Required	Description
`max_results`	No	Maximum number of tweets to return (default: 10)
`query`	Yes	The search query to execute
`twitter_access_token`	Yes	Twitter OAuth2 access token

TDQS

C2.6/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions using the Twitter API but fails to describe key traits: whether it's read-only or has side effects, rate limits, authentication requirements (implied by the twitter_access_token parameter but not explained), or what the search returns (e.g., format, pagination). This is inadequate for a tool with no annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words, making it appropriately concise. However, it's front-loaded with only basic information and lacks structure for more complex details, which slightly limits its effectiveness given the tool's functionality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a search tool with no annotations and no output schema, the description is incomplete. It doesn't explain return values, error handling, or behavioral nuances like rate limiting. With siblings present, it also fails to provide contextual differentiation, leaving significant gaps for an AI agent to understand full usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters (max_results, query, twitter_access_token) with clear descriptions. The description adds no additional meaning beyond what the schema provides, such as query syntax examples or token usage details, resulting in a baseline score of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Search for tweets using the Twitter API' states the basic action (search) and resource (tweets), but it's vague about scope and differentiation. It doesn't specify what kind of search (e.g., public, recent, filtered) or how it differs from sibling tools like twitter_get_user_tweets or twitter_get_user_replies, which also retrieve tweets.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention context (e.g., for general searches vs. user-specific queries), prerequisites like authentication, or exclusions. With siblings like twitter_get_user_tweets for user timelines, the lack of differentiation leaves usage unclear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: getting user replies vs. tweets, posting vs. replying, searching, and token refresh. No overlap exists that would cause misselection, as the descriptions specify unique actions and targets.

Naming Consistency5/5

All tools follow a consistent 'twitter_verb_noun' pattern with snake_case, such as twitter_get_user_replies and twitter_post_tweet. This predictability makes it easy for agents to understand and select tools based on naming conventions.

Tool Count4/5

With 6 tools, the count is reasonable for a Twitter API server, covering core actions like posting, replying, searching, and user data retrieval. It might be slightly under-scoped for a full Twitter client (e.g., missing likes or retweets), but it's well-balanced for basic operations.

Completeness4/5

The toolset covers key Twitter interactions: reading (user tweets/replies, search), writing (post, reply), and authentication (token refresh). Minor gaps exist, such as no tools for liking, retweeting, or deleting tweets, but agents can handle core workflows effectively with the provided tools.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Reddit Discussion

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

twitterapi-mcp-server A
io.github.kaitoInfra
Twitter/X read-only MCP server — 12 tools: search, users, tweets, followers, timelines, trends.
Social Media Search
121
excalibur-mcp A
io.github.lonniev
FastMCP server for posting formatted content to X (Twitter) — Tollbooth-monetized, DPYC-native
Social Media Communication
7823
Arlet
dev.arlet
Create, deploy, and operate MCP servers directly from your GitHub repositories.
Developer Tools CI/CD & DevOps
2
thoughts
ai.thoughtbox.api
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
Cloud Storage Finance
2

Related MCP Servers

Twitter MCP Server
Social Media Communication
aali-1
A
license
Not graded
quality
D
maintenance
Model Context Protocol server that enables programmatic interaction with Twitter API, allowing users to post tweets, search for content, and retrieve user timelines through standardized MCP tools.
Updated a year ago (2025-08-06 02:09 UTC)
19
MIT
TwitterAPI MCP Server
Social Media Search
Jing-yilin
A
license
B
quality
D
maintenance
An MCP server that provides access to Twitter data and write actions through TwitterAPI.io, bypassing the need for a standard Twitter developer account. It enables users to search tweets, retrieve profiles, and post content with support for pagination and enterprise proxy configurations.
Updated 8 months ago (2026-01-10 08:35 UTC)
20
MIT
X(Twitter) V2 MCP Server
Social Media Search
NexusX-MCP
A
license
Not graded
quality
D
maintenance
An MCP server for interacting with the Twitter/X API v2, enabling AI assistants to retrieve tweets, post content, reply, quote, and more programmatically.
Updated a year ago (2025-04-20 13:28 UTC)
2,013
13
MIT
twikit-mcp
Social Media Communication
tangivis
A
license
B
quality
A
maintenance
An MCP server for interacting with Twitter/X using browser cookies without an API key, enabling tweet management, user actions, and search via natural language.
Updated 17 days ago (2026-08-17 08:17 UTC)
62
10
MIT

Appeared in Searches

Information about Douyin

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/baryhuang/mcp-twitter-noauth'

If you have feedback or need assistance with the MCP directory API, please join our Discord server