Un servidor MCP (Protocolo de Contexto de Modelo) que proporciona acceso a la API de Twitter sin necesidad de configurar credenciales ni tokens locales. Proporciona operaciones básicas de Twitter, como buscar tuits, obtener tuits de usuarios, publicar tuits y responder a tuits.
https://www.youtube.com/watch?v=LOxFqCTPedc
Related MCP server: TwitterAPI MCP Server
Operación remota y sin cabeza : este servidor puede ejecutarse de manera completamente sin cabeza en entornos remotos sin navegador ni acceso a archivos locales.
Arquitectura desacoplada : cualquier cliente puede completar el flujo OAuth de forma independiente y luego pasar credenciales como contexto a este servidor MCP, creando una separación completa entre el almacenamiento de credenciales y la implementación del servidor.
Funcionalidad enfocada : proporciona operaciones básicas de Twitter, como buscar tweets, obtener tweets de usuarios, publicar tweets y responder a tweets.
Docker-Ready : diseñado teniendo en cuenta la contenedorización para una configuración con un solo clic, independiente del entorno y bien aislada.
Dependencias confiables : construida sobre la biblioteca de solicitudes de Python estándar para la integración de la API de Twitter.
Buscar tweets usando la API de Twitter
Obtener tweets recientes de un usuario específico
Obtener respuestas recientes de un usuario específico
Publicar nuevos tweets
Responder a tweets existentes
Actualizar los tokens de acceso por separado
Manejo automático de tokens de actualización
Python 3.10 o superior
Credenciales de la API de Twitter (ID de cliente, secreto de cliente, token de acceso y token de actualización)
# 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 .Puede configurar Claude Desktop para usar la imagen de Docker agregando lo siguiente a su configuración de Claude:
{
"mcpServers": {
"twitter": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"buryhuang/mcp-twitter-noauth:latest"
]
}
}
}Nota: Con esta configuración, deberá proporcionar sus credenciales de la API de Twitter en las llamadas a herramientas, como se muestra en la sección "Uso de las herramientas" . Las credenciales de Twitter no se pasan como variables de entorno para mantener la separación entre el almacenamiento de credenciales y la implementación del servidor.
Para publicar la imagen de Docker en varias plataformas, puede usar el comando docker buildx . Siga estos pasos:
Cree una nueva instancia de constructor (si aún no lo ha hecho):
docker buildx create --useConstruya y envíe la imagen para múltiples plataformas :
docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t buryhuang/mcp-twitter-noauth:latest --push .Verifique que la imagen esté disponible para las plataformas especificadas :
docker buildx imagetools inspect buryhuang/mcp-twitter-noauth:latestEl servidor proporciona la funcionalidad de Twitter mediante herramientas MCP. La autenticación se simplifica gracias a una herramienta dedicada a la actualización de tokens.
mcp-server-twitter-noauthAl utilizar un cliente MCP como Claude, tienes dos formas principales de manejar la autenticación:
Si tiene tokens de acceso y actualización:
{
"twitter_access_token": "your_access_token",
"twitter_refresh_token": "your_refresh_token",
"twitter_client_id": "your_client_id",
"twitter_client_secret": "your_client_secret"
}Si su token de acceso ha expirado, puede actualizarlo solo con el token de actualización:
{
"twitter_refresh_token": "your_refresh_token",
"twitter_client_id": "your_client_id",
"twitter_client_secret": "your_client_secret"
}Esto devolverá un nuevo token de acceso y su tiempo de expiración, que puede usar para llamadas posteriores.
Buscar tweets usando la API de Twitter:
{
"twitter_access_token": "your_access_token",
"query": "your search query",
"max_results": 10
}La respuesta incluye datos del tweet, incluido el texto, la hora de creación y la información del autor.
Obtener tweets recientes de un usuario específico:
{
"twitter_access_token": "your_access_token",
"user_id": "twitter_user_id",
"max_results": 10
}Obtener respuestas recientes de un usuario específico:
{
"twitter_access_token": "your_access_token",
"user_id": "twitter_user_id",
"max_results": 10
}Publicar un nuevo tweet:
{
"twitter_access_token": "your_access_token",
"text": "This is a test tweet from the MCP Twitter server"
}Responder a un tweet existente:
{
"twitter_access_token": "your_access_token",
"tweet_id": "id_of_tweet_to_reply_to",
"text": "This is a reply to the original tweet"
}Comience llamando a la herramienta twitter_refresh_token con:
Sus credenciales completas (token de acceso, token de actualización, ID de cliente y secreto de cliente), o
Solo su token de actualización, ID de cliente y secreto de cliente si el token de acceso ha expirado
Utilice el nuevo token de acceso devuelto para llamadas API posteriores.
Si recibe una respuesta que indica la expiración del token, llame a la herramienta twitter_refresh_token nuevamente para obtener un nuevo token.
Este enfoque simplifica la mayoría de las llamadas API al no requerir credenciales de cliente para cada operación y, al mismo tiempo, permite la actualización del token cuando es necesario.
Para obtener las credenciales de API de Twitter necesarias, siga estos pasos:
Crear un nuevo proyecto y aplicación
Configurar la autenticación OAuth 2.0
Configurar los ajustes de OAuth para su aplicación
Generar ID de cliente y secreto de cliente
Complete el flujo OAuth para obtener acceso y tokens de actualización
Este servidor implementa la actualización automática de tokens. Cuando su token de acceso caduque, el servidor utilizará el token de actualización, el ID y el secreto del cliente para obtener un nuevo token de acceso sin necesidad de intervención del usuario.
Este servidor requiere acceso directo a tus credenciales de la API de Twitter. Mantén siempre tus tokens y credenciales seguros y nunca los compartas con terceros no confiables.
Consulte el archivo LICENCIA para obtener más detalles.
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
