一个 MCP（模型上下文协议）服务器，无需设置本地凭证或令牌即可提供 Twitter API 访问。它提供 Twitter 的核心操作，例如搜索推文、获取用户推文、发布推文以及回复推文。
https://www.youtube.com/watch?v=LOxFqCTPedc
Related MCP server: TwitterAPI MCP Server
无头和远程操作：该服务器可以在没有浏览器和没有本地文件访问的远程环境中完全无头运行。
解耦架构：任何客户端都可以独立完成 OAuth 流程，然后将凭证作为上下文传递给此 MCP 服务器，从而在凭证存储和服务器实现之间实现完全分离。
重点功能：提供核心 Twitter 操作，如搜索推文、获取用户推文、发布推文和回复推文。
Docker-Ready ：设计时考虑了容器化，可实现良好隔离、独立于环境的一键式设置。
可靠的依赖项：基于标准 Python 请求库构建，用于 Twitter API 集成。
使用 Twitter API 搜索推文
获取特定用户的最新推文
获取特定用户的最近回复
发布新推文
回复现有推文
单独刷新访问令牌
自动刷新令牌处理
Python 3.10 或更高版本
Twitter API 凭证（客户端 ID、客户端密钥、访问令牌和刷新令牌）
# Clone the repository
git clone https://github.com/yourusername/mcp-twitter-noauth.git
cd mcp-twitter-noauth
# Install dependencies
pip install -e .# Build the Docker image
docker build -t mcp-twitter-noauth .您可以通过将以下内容添加到 Claude 配置中来配置 Claude Desktop 以使用 Docker 镜像：
{
"mcpServers": {
"twitter": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"buryhuang/mcp-twitter-noauth:latest"
]
}
}
}注意：使用此配置，您需要在工具调用中提供您的 Twitter API 凭据，如“使用工具”部分所示。Twitter 凭据不会作为环境变量传递，以保持凭据存储和服务器实现之间的分离。
要为多个平台发布 Docker 镜像，可以使用docker buildx命令。请按以下步骤操作：
创建一个新的构建器实例（如果还没有）：
docker buildx create --use为多个平台构建并推送图像：
docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t buryhuang/mcp-twitter-noauth:latest --push .验证该图像是否适用于指定的平台：
docker buildx imagetools inspect buryhuang/mcp-twitter-noauth:latest该服务器通过 MCP 工具提供 Twitter 功能。通过专用的令牌刷新工具简化了身份验证处理。
mcp-server-twitter-noauth当使用像 Claude 这样的 MCP 客户端时，您有两种主要方式来处理身份验证：
如果您同时拥有访问令牌和刷新令牌：
{
"twitter_access_token": "your_access_token",
"twitter_refresh_token": "your_refresh_token",
"twitter_client_id": "your_client_id",
"twitter_client_secret": "your_client_secret"
}如果您的访问令牌已过期，您可以仅使用刷新令牌进行刷新：
{
"twitter_refresh_token": "your_refresh_token",
"twitter_client_id": "your_client_id",
"twitter_client_secret": "your_client_secret"
}这将返回一个新的访问令牌及其到期时间，您可以在后续调用中使用它。
使用 Twitter API 搜索推文：
{
"twitter_access_token": "your_access_token",
"query": "your search query",
"max_results": 10
}响应包括推文数据，包括文本、创建时间和作者信息。
获取特定用户的最新推文：
{
"twitter_access_token": "your_access_token",
"user_id": "twitter_user_id",
"max_results": 10
}获取特定用户的最近回复：
{
"twitter_access_token": "your_access_token",
"user_id": "twitter_user_id",
"max_results": 10
}发布一条新推文：
{
"twitter_access_token": "your_access_token",
"text": "This is a test tweet from the MCP Twitter server"
}回复现有推文：
{
"twitter_access_token": "your_access_token",
"tweet_id": "id_of_tweet_to_reply_to",
"text": "This is a reply to the original tweet"
}首先使用以下任一方式调用twitter_refresh_token工具：
您的完整凭证（访问令牌、刷新令牌、客户端 ID 和客户端密钥），或
如果访问令牌已过期，则仅显示刷新令牌、客户端 ID 和客户端密钥
使用返回的新访问令牌进行后续 API 调用。
如果收到指示令牌过期的响应，请再次调用twitter_refresh_token工具以获取新令牌。
这种方法不需要每个操作都提供客户端凭据，从而简化了大多数 API 调用，同时仍在需要时启用令牌刷新。
要获取所需的 Twitter API 凭证，请按照以下步骤操作：
创建新项目和应用程序
设置 OAuth 2.0 身份验证
为您的应用配置 OAuth 设置
生成客户端 ID 和客户端密钥
完成 OAuth 流程以获取访问和刷新令牌
此服务器实现了令牌自动刷新功能。当您的访问令牌过期时，服务器将使用刷新令牌、客户端 ID 和客户端密钥来获取新的访问令牌，无需用户干预。
此服务器需要直接访问您的 Twitter API 凭证。请始终确保您的令牌和凭证安全无虞，切勿与不受信任的第三方共享。
有关详细信息，请参阅 LICENSE 文件。
Get recent replies by a specific user
| Name | Required | Description | Default |
|---|---|---|---|
| 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) |
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.
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.
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.
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.
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.
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.
Get recent tweets by a specific user
| Name | Required | Description | Default |
|---|---|---|---|
| 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) |
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.
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.
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.
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.
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.
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.
Post a new tweet
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The tweet text content | |
| twitter_access_token | Yes | Twitter OAuth2 access token |
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.
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.
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.
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.
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.
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.
Refresh the access token using the refresh token and client credentials
| Name | Required | Description | Default |
|---|---|---|---|
| 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 |
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.
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.
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.
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.
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.
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.
Reply to an existing tweet
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The reply text content | |
| tweet_id | Yes | ID of the tweet to reply to | |
| twitter_access_token | Yes | Twitter OAuth2 access token |
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.
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.
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.
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.
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.
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.
Search for tweets using the Twitter API
| Name | Required | Description | Default |
|---|---|---|---|
| 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 |
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.
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.
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.
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.
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.
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.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0twitter_get_user_repliestwitter_get_user_tweetstwitter_post_tweettwitter_refresh_tokentwitter_reply_to_tweettwitter_search_tweetsScored across 6 tools
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.
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.
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.
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.
Official MCP server for twitterapis.com. Read and write Twitter/X: search, users, tweets, DMs.
Official twitterapi.io hosted MCP: Twitter/X tweets, users, followers, trends. OAuth or API key.
Twitter/X read-only MCP server — 12 tools: search, users, tweets, followers, timelines, trends.
FastMCP server for posting formatted content to X (Twitter) — Tollbooth-monetized, DPYC-native
