Skip to main content
Glama
Sign In
thread-storm

thread-storm

by asadhuddleduck
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Remote

Thread Storm

MCP server for publishing threads to Threads and Twitter/X simultaneously from Claude Code. Journal your thoughts, convert them to viral threads, and post everywhere at once.

Features

13 tools available via MCP:

Threads (9 tools)

Tool

Description

threads_get_profile

Fetch Threads profile info

threads_get_posts

List recent posts with pagination

threads_get_post_details

Get full details for a specific post

threads_get_post_insights

Engagement metrics (views, likes, replies, reposts, quotes, shares)

threads_get_replies

Direct replies to a specific post

threads_search

Keyword search across Threads

threads_get_account_insights

Account-level metrics

threads_publish_text

Publish a text post (optional reply)

threads_publish_thread

Publish a multi-post thread

Twitter/X (3 tools)

Tool

Description

twitter_get_profile

Fetch Twitter profile info

twitter_publish_text

Post a tweet (optional reply)

twitter_publish_thread

Post a tweet thread

Cross-Platform (1 tool)

Tool

Description

storm_publish_thread

Publish to BOTH Threads and Twitter simultaneously

Related MCP server: meta-threads-mcp

Prerequisites

  • Python 3.12+

  • uv

  • A Meta developer app with Threads API access

  • A Twitter/X developer app with Read+Write permissions

Quick Start

  1. Clone the repo:

    git clone https://github.com/asadhuddleduck/thread-storm.git
cd thread-storm

  2. Install dependencies:

    uv sync

  3. Add to your .mcp.json:

    {
  "mcpServers": {
    "thread-storm": {
      "command": "uv",
      "args": ["run", "--python", "3.12", "--directory", "/path/to/thread-storm", "thread-storm"],
      "env": {
        "THREADS_ACCESS_TOKEN": "your-threads-token",
        "THREADS_APP_SECRET": "your-threads-app-secret",
        "TWITTER_API_KEY": "your-twitter-api-key",
        "TWITTER_API_SECRET": "your-twitter-api-secret",
        "TWITTER_ACCESS_TOKEN": "your-twitter-access-token",
        "TWITTER_ACCESS_TOKEN_SECRET": "your-twitter-access-token-secret"
      }
    }
  }
}

  4. Restart Claude Code. All 13 tools will be available.

Environment Variables

Variable

Platform

Description

THREADS_ACCESS_TOKEN

Threads

Long-lived token from Meta's User Token Generator

THREADS_APP_SECRET

Threads

App secret from Meta developer app

TWITTER_API_KEY

Twitter

OAuth 1.0a consumer API key

TWITTER_API_SECRET

Twitter

OAuth 1.0a consumer API secret

TWITTER_ACCESS_TOKEN

Twitter

OAuth 1.0a user access token

TWITTER_ACCESS_TOKEN_SECRET

Twitter

OAuth 1.0a user access token secret

Architecture

src/thread_storm/
  threads_client.py   — Threads HTTP client (GET via urllib, POST via curl)
  twitter_client.py   — Twitter client via tweepy (OAuth 1.0a)
  server.py           — FastMCP server with 13 tool definitions

Threads Publishing Flow

  1. Create media container (POST)

  2. Poll container status until FINISHED (2s intervals)

  3. Publish container (POST)

  4. Wait 10s propagation delay before next reply

Twitter Publishing Flow

  1. Post tweet (POST /2/tweets)

  2. Post next tweet with in_reply_to_tweet_id

  3. No polling or delays needed

storm_publish_thread

Runs both platforms in parallel using ThreadPoolExecutor. Twitter finishes in seconds while Threads takes 1-2 minutes for a 9-post thread.

Token Management (Threads)

Threads tokens expire after 60 days. Auto-refresh kicks in at day 30:

  1. Token saved to ~/.threads-mcp/token.json on first use

  2. After day 30, exchanged for a fresh 60-day token

  3. New token saved to both token.json and .mcp.json

Twitter OAuth 1.0a tokens do not expire.

Rate Limits

  • Threads publishing: 250 posts per 24 hours

  • Threads search: 500 queries per 7 days

  • Twitter publishing: 500 tweets per month (Free tier)

License

MIT

Available Tools

13 tools
storm_publish_threadA

Publish a thread to BOTH Threads and Twitter/X simultaneously.

This is the hero tool. Takes a list of text strings and publishes them as a connected thread on both platforms in parallel. Threads posts are slower (container polling + propagation delays) while Twitter is near-instant.

Args: posts: List of text strings to publish as a thread on both platforms.

Returns: JSON string with results from both platforms including post IDs and permalinks.

Inputs: posts (required). Returns: result

threads_get_account_insightsA

Fetch account-level engagement metrics for the authenticated user.

Args: period: Time period for metrics. Valid values: "day", "week", "days_28", "lifetime".

Returns: JSON string with account metrics including views, likes, and followers count.

Inputs: period. Returns: result

threads_get_post_detailsA

Fetch detailed information about a specific Threads post.

Args: post_id: The ID of the post to retrieve.

Returns: JSON string with post details including text, timestamp, media type, permalink, and quote status.

Inputs: post_id (required). Returns: result

threads_get_post_insightsA

Fetch engagement metrics for a specific Threads post.

Args: post_id: The ID of the post to get insights for.

Returns: JSON string with metric name/value pairs for views, likes, replies, reposts, quotes, and shares.

Inputs: post_id (required). Returns: result

threads_get_postsA

Fetch the authenticated user's recent Threads posts.

Args: limit: Maximum number of posts to return (default 25). cursor: Pagination cursor from a previous response to fetch the next page.

Returns: JSON string with a list of posts and pagination info (next cursor if available).

Inputs: limit, cursor. Returns: result

threads_get_profileA

Fetch the authenticated user's Threads profile information.

Returns: JSON string with profile data including id, username, name, bio, and profile picture URL.

Inputs: no named parameters. Returns: result

threads_get_repliesA

Fetch direct replies to a specific Threads post.

Returns only single-level direct replies, not recursive thread reconstruction.

Args: post_id: The ID of the post to get replies for. limit: Maximum number of replies to return (default 25).

Returns: JSON string with a list of replies including id, text, timestamp, and username.

Inputs: post_id (required), limit. Returns: result

threads_publish_textA

Publish a text post to Threads, optionally as a reply to another post.

Use reply_to_id to chain posts into a thread (each post replies to the previous one). Limit: 250 API-published posts per 24-hour window. Max 500 characters per post.

Args: text: The text content to publish. reply_to_id: Optional post ID to reply to (for building threads).

Returns: JSON string with the published post ID and permalink.

Inputs: text (required), reply_to_id. Returns: result

threads_publish_threadA

Publish a full thread (multiple posts chained as replies) to Threads.

Takes a list of text strings and publishes them sequentially. The first post becomes the root, and each subsequent post replies to the previous one.

Args: posts: List of text strings to publish as a thread (7-12 posts typical).

Returns: JSON string with all published post IDs, permalinks, and the root permalink.

Inputs: posts (required). Returns: result

threads_searchA

Search Threads for posts matching a keyword query.

Note: The Threads API allows 500 keyword search queries per rolling 7-day period.

Args: query: The search query string. limit: Maximum number of results to return (default 25).

Returns: JSON string with matching posts including id, text, timestamp, and permalink.

Inputs: query (required), limit. Returns: result

twitter_get_profileA

Fetch the authenticated user's Twitter/X profile information.

Returns: JSON string with profile data including id, username, name, bio, and follower counts.

Inputs: no named parameters. Returns: result

twitter_publish_textA

Publish a tweet to Twitter/X, optionally as a reply to another tweet.

Args: text: The tweet content (280 chars standard, 25000 for Premium). reply_to_id: Optional tweet ID to reply to.

Returns: JSON string with the published tweet ID and permalink.

Inputs: text (required), reply_to_id. Returns: result

twitter_publish_threadA

Publish a full thread (multiple tweets chained as replies) to Twitter/X.

Args: posts: List of text strings to publish as a tweet thread.

Returns: JSON string with all published tweet IDs and permalinks.

Inputs: posts (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

    TDQS

    A4.2/5.0

    Scored across 13 tools

    Disambiguation5/5

    Each tool targets a distinct resource-action pair: profiles, posts, details, insights, replies, search, and publishing variants. The only potential overlap between threads_publish_thread and storm_publish_thread is clearly delineated by their descriptions (single-platform vs dual-platform).

    Naming Consistency5/5

    All tools follow a consistent snake_case verb_noun pattern with platform prefixes (threads_, twitter_, storm_). Verbs are limited to get, publish, and search, and resources are clearly named (profile, posts, details, insights, thread). No naming style deviations.

    Tool Count5/5

    13 tools is appropriate for a server covering two social platforms plus a combined publishing feature. Each tool fills a clear role, and the count is within the ideal 3-15 range without feeling sparse or bloated.

    Completeness4/5

    Core workflows are well covered: profile retrieval, post reading, insights, searching, and publishing single posts or threads on Threads, plus publishing on Twitter. The main gaps are the lack of Twitter read operations (e.g., fetching tweets, timeline) and no update/delete functionality, but these are minor for the server's evident cross-posting focus.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Resources

    Related MCP Connectors

    Related MCP Servers

    • meta-threads-mcp

      MetaThreads
      A
      license
      A
      quality
      D
      maintenance
      Unofficial MCP server for Meta's Threads API. Enables LLMs like Claude to publish posts, manage replies, and track insights through the Model Context Protocol.
      15
      MIT

    • markpost

      nsmith
      F
      license
      A
      quality
      D
      maintenance
      An MCP server that formats and syndicates Markdown content to Twitter/X, Threads, and a static blog on S3, with automatic thread splitting and preview capabilities.
      3
      -