SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

Threads MCP server for AI agents and assistants

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Threads MCP or direct API to publish posts, manage replies, discover public content, and analyze profile performance through natural language.

Get started for freeGet a demo
Threads logoThreads
Oauth2

Threads is Meta's social network for publishing posts, managing replies, discovering content, and tracking performance. It helps creators and brands engage audiences and measure what resonates.

24 Tools

Try Threads now

Type what you want done — sign in and watch it run live in the Tool Router playground.

TOOL ROUTER PLAYGROUND
Threads
Try asking
TOOLS

Supported Tools

Every Threads action and event your agent gets out of the box.

Create and Share Post

Create and publish a top-level Threads post and cross-share it to the linked Instagram account as a Story.

Create Post

Create and publish a top-level Threads text, image, video, carousel, quote, poll, ghost, GIF, or text-attachment post, optionally with a location tag.

Create Reply

Create and publish a reply to a Threads post, including a text, image, video, carousel, quote, poll, GIF, or text-attachment reply.

Delete Post

Permanently delete a Threads post owned by the connected profile.

Get Location

Retrieve one Threads location by ID for inspection or post tagging.

Get My Profile

Return the connected or app-scoped Threads user's profile and identity fields.

Get Post

Retrieve one Threads post by ID.

Get Post Embed

Return embeddable HTML and oEmbed metadata for a public Threads post.

Get Post Insights

Return selected lifetime engagement metrics for one post owned by the connected Threads profile.

Get Profile Insights

Return one time-window page of selected profile time-series, totals, link clicks, follower counts, or follower demographics for a Threads profile.

Get Publishing Limits

Return current usage and configured quota for Threads posts, replies, deletes, location searches, or all publishing categories.

List Ghost Posts

List active and archived ghost posts created by the connected Threads profile, one cursor page at a time.

List My Mentions

List public Threads posts that mention the connected profile, one cursor page at a time.

List My Posts

List posts created by the connected Threads profile, one cursor page at a time.

List My Replies

List replies created by the connected Threads profile, one cursor page at a time.

List Pending Replies

List one page of pending or ignored replies for an owned Threads post.

List Post Replies

Return either immediate replies or the flattened full conversation for a Threads post, one cursor page at a time.

List Public Profile Posts

List one cursor page of posts from a qualifying public Threads profile by exact username.

Lookup Public Profile

Look up a qualifying public Threads profile by exact username.

Repost Post

Repost an existing Threads post to the connected profile; this creates a visible post.

Review Pending Reply

Approve or ignore one pending reply; an ignored reply can later be approved.

Search Locations

Search Threads locations by text, coordinates, or both.

Search Posts

Search one page of Threads posts by keyword or topic tag.

Set Reply Visibility

Hide or unhide a top-level reply and its nested replies on a post managed by the connected profile.

SETUP GUIDE

Connect Threads MCP Tool with your Agent

1

Install Composio

typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
Install the Composio SDK and your agent framework
2

Create a session with MCP enabled

typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["threads"],
  mcp: true,
});
Create a session scoped to Threads and read its MCP URL and headers
3

Connect your agent to the MCP server

typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "Publish a Threads post saying 'Our new product update is live today.'",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
Pass the session's MCP URL and headers to your agent and run a Threads request
SETUP GUIDE

Connect Threads API Tool with your Agent

1

Install Composio

typescript
npm install @composio/core @composio/openai openai
Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
2

Create a Composio session

typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["threads"] });
const tools = await session.tools();
Initialize Composio with the OpenAI Responses provider and create a session scoped to Threads
3

Run Threads tools with your agent

typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "Publish a Threads post saying 'Our new product update is live today.'" }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
Send a request, execute the Threads tool calls through the session, and print the final answer

Why Use Composio?

AI Native Threads Integration

  • Supports both Threads MCP and direct API based integrations
  • Structured, LLM-friendly schemas for reliable tool execution
  • Rich coverage for publishing, replying, discovering, and analyzing Threads content

Managed Auth

  • Built-in OAuth handling with automatic token refresh and rotation
  • Central place to manage, scope, and revoke Threads access
  • Per user and per environment credentials instead of hard-coded keys

Agent Optimized Design

  • Tools are tuned using real error and success rates to improve reliability over time
  • Comprehensive execution logs so you always know what ran, when, and on whose behalf

Enterprise Grade Security

  • Fine-grained RBAC so you control which agents and users can access Threads
  • Scoped, least privilege access to Threads resources
  • Full audit trail of agent actions to support review and compliance
FRAMEWORKS

Use Threads with any AI Agent Framework

Choose a Framework you want to connect Threads with

ChatGPT logo

ChatGPT

Use Threads MCP with ChatGPT

Claude Cowork logo

Claude Cowork

Use Threads MCP with Claude Cowork

Hermes logo

Hermes

Use Threads MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Threads MCP with Atomic Agent

Rolling this out across your team?

Give your team centralized access control across every framework with Composio’s MCP Gateway.

EXPLORE MCP GATEWAY
FAQ

Frequently asked questions

Start with Threads.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Threads tool your agent needs.Free to start.

Start building