Twitter MCP connector for AI agents

Tools your social media agent reaches for on Twitter MCP, scoped per user.

CALL ANY TOOL

100 tools for social media on Twitter MCP: search and read Posts, look up users, manage Lists and Bookmarks, create Posts, handle Chat conversations, and schedule broadcasts and calls.

twittermcp_accept_chat_message_request

Accept chat message request

Accepts the other user's pending message request in a 1:1 Chat conversation, which moves to the authenticated user's inbox. Without a pending request, including after a successful accept, the response is 404. Replying to a request does not accept it.

Parameters

Name

Type

Required

Description

string

Required

The other user's ID, or both user IDs joined by a hyphen.

twittermcp_add_chat_moderator

Add chat moderator

twittermcp_archive_chat_conversation

Archive chat conversation

twittermcp_article_create_draft

Article create draft

twittermcp_cancel_scheduled_call

Call cancel scheduled

twittermcp_chat_media_upload_append

Chat media upload append

twittermcp_create_scheduled_broadcast

Create scheduled broadcast

twittermcp_delete_scheduled_broadcast

Delete scheduled broadcast

twittermcp_follow_list

List follow

twittermcp_get_broadcast

Get broadcast

twittermcp_get_chat_conversations

Get chat conversations

Retrieves a list of Chat conversations for the authenticated user's inbox, newest first: the most recently active conversation comes first. The unread, last_read_event_id and newest_event_id fields give your read state, computed from your latest read receipt and each conversation's latest notifying message. Request them with chat_conversation.fields=unread,last_read_event_id,newest_event_id. The filters unread_only, type, is_archived, is_muted, participant_ids, participant_query, start_time and end_time are optional, and all filters must match (AND). participant_query keeps conversations where another participant's username, or a word of their display name, starts with the query, ignoring case and accents; with a leading @ it matches usernames only. It considers the 100 people who best match the query, uses only public profile information, and never matches group names, nicknames or messages. start_time and end_time apply to the time of each conversation's latest message. Each page covers max_results conversations and returns those that match, so a page can hold fewer than max_results, or none, while meta.next_token is set and has_more is true: keep paging, passing meta.next_token as pagination_token. Once a page reaches a conversation whose latest message is older than start_time, has_more is false. A pagination_token only works with the same filters as the request that returned it; with other filters, the request fails with a 400. When both are provided, `start_time` must be earlier than `end_time`.

Parameters

Name

Type

Required

Description

chat_conversation.fields

string

Optional

A comma separated list of ChatConversation fields to display.

end_time

string

Optional

ISO 8601, e.g. 2026-10-17T00:00:00Z. Chats whose latest message is before this time.

expansions

string

Optional

A comma separated list of fields to expand.

is_archived

boolean

Optional

true: only archived; false: only not archived. Omit for both.

is_muted

boolean

Optional

true: only muted; false: only not muted. Omit for both.

max_results

integer

Optional

Conversations covered per page (1-1000, default 200). Filtered pages can return fewer.

pagination_token

string

Optional

meta.next_token from the previous page. Send the same filters with it, or the request fails.

participant_ids

string

Optional

Comma-separated numeric user IDs (1-10), all in the chat. Names or @handles: use participant_query.

participant_query

string

Optional

Name or @username prefix (1-50 chars); keeps chats where any other participant matches it.

start_time

string

Optional

ISO 8601, e.g. 2026-10-16T00:00:00Z. Chats whose latest message is at or after this time.

type

string

Optional

Only direct (1:1) or only group conversations. Omit for both. One of: `direct`, `group`.

unread_only

boolean

Optional

Return only unread conversations. A page can be short; keep paging while has_more.

user.fields

string

Optional

A comma separated list of User fields to display.

twittermcp_get_communities_by_id

Get communities by id

twittermcp_get_news

Get news

twittermcp_get_posts_liking_users

Get posts liking users

twittermcp_get_scheduled_call

Call get scheduled

twittermcp_get_spaces_posts

Get spaces posts

twittermcp_get_users_bookmark_folders

Get users bookmark folders

twittermcp_get_users_by_username

Get users by username

twittermcp_get_users_me_followers

Get users me followers

twittermcp_get_users_pinned_lists

Get users pinned lists

twittermcp_list_scheduled_broadcasts

List scheduled broadcasts

twittermcp_mark_chat_conversation_read

Read mark chat conversation

twittermcp_mark_chat_conversation_unread

Mark chat conversation unread

twittermcp_pin_list

List pin

twittermcp_remove_chat_moderator

Remove chat moderator

twittermcp_search_communities

Search communities

twittermcp_search_posts_all

Search posts all

twittermcp_send_chat_message

Send chat message

Sends a message or reaction to a specific Chat conversation. Send `encoded_message_create_event`, an end-to-end encrypted event built with the Chat XDK. `content`, a plaintext message or reaction sent unencrypted, is only a fallback for a 1:1 conversation that X Chat can't encrypt because one of the two users has connected an enterprise app that reads their DMs; check that the recipient's `receives_your_chat` user field is `unencrypted` before using it. Otherwise a `content` send is refused, and retrying it won't help: HTTP 400 https://api.x.com/2/problems/encryption-required when the conversation can be encrypted or is a group (send `encoded_message_create_event` instead), 400 https://api.x.com/2/problems/xchat-setup-required when you haven't set up X Chat, 400 https://api.x.com/2/problems/recipient-xchat-setup-required when the recipient hasn't, and 403 https://api.x.com/2/problems/message-request-not-supported when it would be a message request. HTTP 503 https://api.x.com/2/problems/chat-permissions-unavailable means the check failed and nothing was sent; retry it. For 1:1 conversations, provide the recipient's user ID; the server constructs the canonical conversation ID from the authenticated user and recipient. A recipient who cannot be messaged (closed inbox, system/notification account, or a 1:1 block) returns HTTP 403 with type https://api.x.com/2/problems/recipient-not-messageable.

Parameters

Name

Type

Required

Description

string

Required

The Chat conversation ID. For a 1:1 conversation, provide the recipient's user ID. Sending posts a real message from the authenticated account.

message_id

string

Required

Unique identifier for this message.

content

object

Optional

Plaintext message or reaction sent unencrypted. Only a fallback for 1:1 conversations that X Chat cannot encrypt; otherwise use encoded_message_create_event. Provide one of message, reaction_add or reaction_remove as a JSON object.

conversation_token

string

Optional

Optional conversation token.

encoded_message_create_event

string

Optional

Base64-encoded Thrift MessageCreateEvent containing encrypted message contents. Omit when sending...

encoded_message_event_signature

string

Optional

Base64-encoded Thrift MessageEventSignature for message verification.

xdk_version

string

Optional

Version of the Chat XDK that produced the payload.

twittermcp_unarchive_chat_conversation

Unarchive chat conversation

twittermcp_update_lists

Update lists

For more tools, view docs.

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Twitter tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["twittermcp"], toolNames: [
    "twittermcp_get_users_by_username",
    "twittermcp_get_users_posts",
    "twittermcp_search_posts_all"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Look up this account and summarize what it has posted about our launch" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["twittermcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Look up this account and summarize what it has posted about our launch" }],
  tools,
});

// Execute the tool call with the user's vaulted Twitter OAuth token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["twittermcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Look up this account and summarize what it has posted about our launch" }],
  tools,
});

// Tool call runs with the user's vaulted Twitter OAuth token
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["twittermcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "twitter_mcp_agent",
  model: "gemini-2.5-pro",
  instruction: "Twitter tools scoped to this user",
  tools,
});

await agent.run("Look up this account and summarize what it has posted about our launch");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Twitter MCP tool. Click to copy, paste into your agent, done.

Search and read

Copy the prompt

Copied

Search the full archive for Posts about our product launch.

Copy the prompt

Copied

Show the latest Posts from this username.

Copy the prompt

Copied

What topics are trending in New York right now?

Users and lists

Copy the prompt

Copied

Look up this account by username.

Copy the prompt

Copied

List the members of our competitor watch List.

Copy the prompt

Copied

Add this user to our customer List.

Posting and bookmarks

Copy the prompt

Copied

Create a Post announcing the new connector.

Copy the prompt

Copied

Bookmark this Post in my Research folder.

Copy the prompt

Copied

Show Posts in my Bookmarks.

SEE HOW AUTH WORKS

Each user signs in to Twitter once, and Scalekit stores and refreshes their tokens. Credentials stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

Twitter MCP

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Twitter MCP

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Twitter MCP

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Twitter MCP

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other marketing and communication connectors.

GTM and RevOps Teams

Competitive intelligence briefing agent

Scans Gong calls for competitor mentions, matches each one to its Notion battlecard, and DMs every affected rep a single Slack digest per cycle. Every call runs as the PMM who owns the briefing, never a shared bot.

GTM and RevOps Teams

Outbound prospecting agent

Searches Apollo for prospects matching your ICP, scores and ranks them, drafts personalized outreach in Gmail, and logs every send to Google Sheets. Mail goes out as the rep, not from a shared inbox.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Twitter token looks fine in a demo. In production every Post, List change, and Chat action looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Twitter today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Twitter as the user or through a shared service account?

As the user. Each user signs in to Twitter once, and Scalekit stores and refreshes their tokens. Posts, List changes, and Chat actions the agent takes are attributed to that user in your audit trail, not a shared service account.

Where is the Twitter OAuth token stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in Twitter?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example the search and get tools without twittermcp_create_posts or twittermcp_delete_scheduled_broadcast. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Twitter access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Can the agent send Chat messages?

Yes, if you expose twittermcp_send_chat_message. It sends a message or reaction to a Chat conversation and expects an end-to-end encrypted event built with the Chat XDK. Leave it out of toolNames to keep the agent to reading and search.