Faust Threads MCP
Provides tools for interacting with the Threads API, including reading latest posts, retrieving post and account insights, follower demographics, and publishing posts or replies (writes disabled by default).
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Faust Threads MCPShow me my latest Threads posts"
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.
Faust Threads MCP
Standalone Python MCP server for the official Meta Threads API. It is portable: it does not import the Faust blog, read local author files, or require a repository path.
Install and run
python -m venv .venv
# Windows: .venv\\Scripts\\activate
# Linux/macOS: . .venv/bin/activate
python -m pip install -e ".[test,quality]"
export THREADS_ACCESS_TOKEN="replace-with-your-token" # PowerShell: $env:THREADS_ACCESS_TOKEN="..."
faust-threads-mcpConfigure an MCP client with stdio:
{
"mcpServers": {
"threads": {"command": "faust-threads-mcp", "env": {"THREADS_ACCESS_TOKEN": "REPLACE_ME"}}
}
}The package never prints tokens. API errors are redacted and provider paging.next URLs are never fetched or persisted; only validated paging.cursors.after values are followed. The approval ledger uses an OS file lock plus atomic replacement, so receipt consumption is serialized across concurrent processes on Windows and POSIX.
Related MCP server: meta-threads-mcp
Tools
threads_latest_posts: real/me/threadsposts, bounded cursor pagination, explicit completeness.threads_post_insights: all documented media metrics:views,likes,replies,reposts,quotes,shares.threads_account_insights: all documented user metrics:views,likes,replies,reposts,quotes,clicks,followers_count, with coverage and time-window metadata.threads_follower_demographics:country,city,age, orgenderbreakdown. Meta requires one breakdown and at least 100 followers.threads_publish_post/threads_publish_reply: disabled by default; requireTHREADS_ENABLE_WRITES=1plus a signed, externally issued, single-use approval receipt bound to exact text, account, reply target, and expiry. A reply uses the officialreply_to_idflow.
Published-post editing is not exposed: the official API capability is not claimed and delete/repost is not substituted.
Included latest-post snapshot
data/latest_posts.json is a synthetic fixture and contains no author data. The live MCP tool is the source of truth for current latest posts and reports pagination coverage. No private API snapshot is part of this package.
Official API scope
The implementation follows Meta's official documentation:
Required permissions depend on the operation: threads_basic; threads_manage_insights for insights; threads_content_publish for posts; and threads_manage_replies for replies. UI-only Insights observations are not represented as API fields.
Development and verification
python -m pytest --cov=faust_threads_mcp --cov-report=term-missing --cov-fail-under=100
ruff check src tests
ruff format --check src tests
mypy src
bandit -q -r srcTests use a mocked transport for all writes and validate an actual MCP SDK stdio client handshake/list/call, including cross-process receipt idempotency. No test sends a network write.
Licensing
This project is licensed under the MIT License; see LICENSE.
Available Tools
6 toolsthreads_account_insightsC
Fetch documented user insights with explicit coverage and window.
| Name | Required | Description | Default |
|---|---|---|---|
| since | No | ||
| until | No | ||
| metrics | No |
TDQS
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. The phrase 'with explicit coverage and window' hints that the caller must specify a metrics coverage and a time range, but the description does not state what happens when coverage is incomplete, how errors surface, whether auth is required, or what data availability constraints exist. Some signal is present, but far less than a no-annotation tool requires.
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 the main verb front-loaded and no obvious filler. However, it borders on under-specification — 'documented' and 'user' add little, and the sentence is so terse that it sacrifices explanatory value rather than achieving disciplined brevity.
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 3 undocumented parameters, no annotations, no output schema, and 5 siblings creating ambiguity, a 10-word description is grossly insufficient. Missing entirely are the expected time format, valid metric values, response shape, and any differentiation from sibling insight tools. The agent cannot correctly invoke this tool based on the provided definition alone.
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 0%, so the parameters 'since', 'until', and 'metrics' carry only type information (integer, integer, array of strings). The description adds a minimal hint that since/until form a 'window' and metrics form 'coverage', which is helpful but still leaves format, units, and valid metric names entirely unspecified. The description does not meaningfully compensate for the zero-coverage schema.
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 identifies a specific operation ('Fetch') on a resource ('documented user insights'), which suggests account-level analytics and roughly separates it from publishing and latest-posts siblings. However, the word 'documented' is confusing and never explained, and the description does not clarify how this differs from threads_post_insights or threads_follower_demographics. The resource framing is decent, but the ambiguity about what 'documented' means prevents a higher 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?
No guidance is given about when to choose this tool versus any of its five siblings. There are no usage conditions, no exclusions, and no mention of alternatives like threads_post_insights for post-level data or threads_follower_demographics for demographic breakdowns. An agent comparing insight tools would have to guess which one fits the task.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threads_follower_demographicsB
Fetch follower demographics for one documented breakdown.
| Name | Required | Description | Default |
|---|---|---|---|
| breakdown | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. The word 'Fetch' clearly implies a read-only operation, and 'for one documented breakdown' hints at the single-parameter constraint. However, it does not describe the return format, pagination, permissions, or any other behavioral details, which is a notable gap with no annotations.
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, front-loaded sentence with no wasted words. The phrase 'one documented breakdown' is slightly ambiguous, but overall the structure is efficient and easy to scan.
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?
This is a simple one-parameter tool with no output schema, so the bar for completeness is moderate. The description plus the enum schema is enough to make an initial call, but it lacks information about return values, how the selected breakdown affects the response, and when this tool is the right choice among sibling analytics tools.
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 0%, and the description does not compensate by explaining the breakdown parameter beyond calling it 'documented.' The schema's enum provides the allowed values (country, city, age, gender), but the description adds little semantic meaning about what each breakdown represents or how the output will be shaped.
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 states a clear verb and resource: 'Fetch follower demographics.' It adds the qualifier 'for one documented breakdown,' which conveys that a single breakdown type is selected, but it does not explicitly distinguish itself from sibling tools like threads_account_insights or threads_post_insights.
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 intended use is implied by the resource name and description: use it when you need follower demographics. However, there is no explicit guidance about when to choose this tool over sibling analytics tools, nor any mention of context such as account-level vs post-level data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threads_latest_postsC
Fetch real latest posts with cursor pagination.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| pages | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It does disclose a meaningful behavioral trait ('cursor pagination') and indicates a read-only operation via 'Fetch', but it omits details like ordering, rate limits, authentication needs, or how the cursor is managed.
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, front-loaded sentence with no extraneous detail. It is concise and readable, though 'real' adds minor ambiguity without clear value.
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 paginated list tool with no output schema and no annotations, the description is too thin. It does not cover return format, pagination semantics, or cursor handling, which are important for an agent to use it correctly.
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 0%, so the description needed to clarify the two parameters but does not. 'limit' and 'pages' are self-explanatory at a surface level, but the description does not explain how they interact with cursor pagination or what behavior 'pages' implies.
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 states a specific verb ('Fetch'), a clear resource ('real latest posts'), and a distinguishing mechanism ('cursor pagination'). It clearly separates this read tool from the sibling publish and insights tools, though 'real' is slightly ambiguous.
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 is provided on when to use this tool versus the sibling tools. The name and description imply it is for retrieving recent posts, but there are no explicit conditions, exclusions, or alternative suggestions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threads_post_insightsB
Fetch all documented media insight metrics.
| Name | Required | Description | Default |
|---|---|---|---|
| post_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The word 'Fetch' clearly indicates a read-only operation, and 'all documented metrics' gives a sense of the return scope. However, with no annotations carrying the burden, the description does not mention authentication requirements, possible empty results, or whether the metrics are period-based or lifetime-based.
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 sentence with no filler and the verb is front-loaded. It is easy to scan and does not waste tokens.
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 one required parameter, the definition is minimally usable: an agent knows what action to perform and can see post_id is required. But because there is no output schema and no description of the returned metrics or permissions, the agent cannot fully predict the response or invocation prerequisites.
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 0%, and the tool description does not explain post_id, its format, or how it maps to a Threads post. The parameter name is self-explanatory to some degree, but the description adds no semantic value beyond the raw schema.
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 names a concrete action ('Fetch') and a resource ('documented media insight metrics'), and the tool name ties it to a specific post. This distinguishes it from account insights, follower demographics, and publishing tools, though the description does not explicitly say 'for a given post' and relies partly on the tool name.
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?
There is no explicit when-to-use or when-not-to-use guidance. An agent must infer from the tool name and sibling tool names that this is the per-post analytics tool rather than threads_account_insights or threads_follower_demographics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threads_publish_postD
Publish only with explicit environment enablement and author approval receipt.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| user_id | Yes | ||
| approval_receipt | Yes |
TDQS
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 does add one meaningful constraint — that publishing requires explicit environment enablement and an author approval receipt — which hints at a guardrail on the operation. However, it discloses nothing about what the call does on success, whether it mutates state, what errors can occur when approval is missing, or what the response looks like.
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 short enough, but it prioritizes a precondition over the core purpose, making it cryptic rather than concise. The single sentence reads like an enforcement rule rather than a functional explanation, and it withholds the information an agent actually needs to invoke the tool correctly.
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 three required parameters, including a nested object, and no output schema or annotations, this description is grossly inadequate. The agent cannot determine the format of approval_receipt, the meaning of user_id, or the operational outcome, so the definition is incomplete on almost every axis an agent needs.
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 0% and the description explains none of the three parameters. The approval_receipt object's structure is entirely undocumented, and user_id and text are given no semantic context. With zero schema docs and zero parameter explanation, an agent cannot know what values to supply, especially for the nested approval_receipt.
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 implies a publishing action through the verb 'Publish' and the tool name references posts, but the sentence is framed as a conditional precondition ('Publish only with...') rather than a clear statement of what the tool does. An agent must infer the verb and resource from the name plus a terse condition rather than being told directly that this publishes a post to Threads.
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?
There is no guidance on when to use this tool versus its sibling threads_publish_reply, which is the closest alternative and would presumably apply when targeting a reply rather than a standalone post. No exclusions, preconditions beyond the cryptic approval requirement, or context are given, so the agent cannot decide between this and the sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threads_publish_replyC
Publish a reply only with explicit environment enablement and author approval receipt.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| user_id | Yes | ||
| reply_to_id | Yes | ||
| approval_receipt | Yes |
TDQS
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 does reveal a non-obvious gating condition: publishing requires environment enablement and an author approval receipt. However, it does not explain what happens if these are missing, what side effects occur, or what authorization or environment setup is required.
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 sentence with no filler and gets to the point quickly. It is concise and front-loaded with the core action, though the ambiguous 'environment enablement' wording could be clearer without adding much length.
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 four required parameters, a nested object, no output schema, and no annotations, the description is under-specified. It leaves unanswered what approval_receipt should look like, what 'environment enablement' means, how the reply relates to reply_to_id, and what the tool returns. These are material gaps for a mutation-like publishing tool.
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 0%, and the description does not compensate. It only echoes the concept of an approval receipt, but it does not explain the required structure of approval_receipt or the meaning of user_id, reply_to_id, and text. An agent cannot learn how to construct a valid invocation from this description.
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 and object: 'Publish a reply.' This distinguishes it from the sibling threads_publish_post and the read-only insight tools. However, the phrase 'explicit environment enablement' is vague and not explained, keeping it from being a fully clear purpose statement.
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 gives a precondition ('only with explicit environment enablement and author approval receipt') but no guidance on when to choose this tool over threads_publish_post or how to determine eligibility. It does not mention alternatives, exclusions, or expected workflow context, leaving usage largely inferred from the tool name and siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
threads_account_insights - First observed
threads_follower_demographics - First observed
threads_latest_posts - First observed
threads_post_insights - First observed
threads_publish_post - First observed
threads_publish_reply
TDQS
Scored across 6 tools
Each tool targets a clearly distinct resource and action: feed retrieval, post-level insights, account-level insights, follower demographics, publishing a post, and publishing a reply. Even the two insights tools are explicitly separated by media metrics versus user metrics.
All tools share the threads_ prefix and use readable snake_case, which makes the set feel cohesive. However, read tools use noun phrases like threads_post_insights while write tools use publish_ verbs, so the convention is not uniformly verb_noun.
Six tools is well-scoped for a Threads-focused server. Each tool covers a distinct need without unnecessary bloat or redundancy.
The server covers the core Threads workflows: reading posts, fetching insights, viewing demographics, and publishing content. It is missing update/delete operations and perhaps single-post retrieval, but these are not critical for the apparent analytics-and-publishing focus.
Maintenance
Related MCP Connectors
- MysocialOAuthio.mysocial
Social media MCP server: your Instagram, TikTok, YouTube, LinkedIn and Threads history for your AI.
Official TimeToPost MCP server for social post drafting, scheduling, publishing and approval queues.
Public threads, replies, and peer discovery for AI agents. Read publicly; use a private key to post.
PerfectPost is a LinkedIn content management platform. This MCP server gives AI assistants read and write access to a user's PerfectPost account: published posts with their engagement analytics, drafts lifecycle (create / edit / schedule), and LinkedIn profile data.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA stdio MCP server for the official Threads API, enabling publishing, reading, moderation, insights, discovery, locations, and setup diagnostics.2MIT
- AlicenseAqualityCmaintenanceUnofficial MCP server for Meta's Threads API. Enables LLMs like Claude to publish posts, manage replies, and track insights through the Model Context Protocol.15MIT
- AlicenseAqualityBmaintenanceCustom MCP server for Threads (Meta) — post, reply, and read insights via the official free Threads API.53 npmMIT
- FlicenseNot gradedqualityBmaintenanceA local-first MCP server for reading, planning, scheduling, and publishing Meta Threads posts, with OAuth and Keychain integration.-