Post to Threads from Claude or ChatGPT with an MCP server

What Threads account do I need?

The Threads account attached to your Instagram login. In Hub, Threads is its own channel: connecting Instagram does not connect Threads, so add it separately even if your Instagram is already in Hub.

1. Open Accounts in Hub and choose Threads, or ask the assistant to call connect_channel with platform set to threads. That tool only returns a link and an instruction for a person. It needs the channels:connect permission, which is not selected by default on Hub’s consent screen.
2. Open the link and sign in to Threads yourself.
3. Tell the assistant you are done. It calls list_channels with refresh: true and uses the returned Threads channel ID, which begins with spc_. A username is not a substitute for that ID.

Connect Claude, ChatGPT, Cursor or another MCP client

Every client uses the same server URL, https://www.mellow.world/mcp. Menus change between client versions, so the official guides linked below describe the current screens. The last column says only what Mellow itself has tested.

1. Add the server in your client and select Connect. Sign in to Mellow if asked. Hub’s consent screen names the app that is asking.
2. Choose the permissions the task needs (below), select your Threads channel, choose review or autopilot, a daily ceiling and an expiry, then approve.
3. Back in the client, run the read-only check from the prompts below. Confirm the profile, the mode and the Threads channel ID. Agents shows the grant’s permissions, channels and expiry, which a client’s summary may leave out.
4. If a client cannot complete OAuth, create a key in Agents and set it as the client’s Authorization: Bearer header, from its secret settings or an environment variable. Never paste a key into a chat.

Which permissions to approve

For a first check, approve only the two default permissions. When the assistant needs to publish, approve a new delegation that includes the publishing permissions.

What you delegate, and how to take it back

Hub treats an assistant’s access as a delegation you give once, with limits. On the OAuth consent screen you choose the permissions, the channels (the ones you select, or explicitly all), review or autopilot, a daily ceiling of 1 to 1,000 posts (50 by default) and an expiry of 1, 7 or 30 days (7 by default). Review is the default mode: the assistant prepares a post and it waits for you. A key or a connected app cannot approve its own post.

An API key is created by you, signed in, in Agents. It belongs to one profile and carries its own mode and daily limit; through the REST key route it can also be limited to channels and given an expiry. A key cannot create another key. Hub records the posts an assistant creates or has refused, approvals, reschedules, cancellations and connection attempts in a journal you read in Agents. Revoking a key or a connected app takes effect on its next request. Publishing always needs an idempotency key, so a retried request cannot publish twice.

Threads rules Hub checks before anything is sent

This table is generated from the registry that validate_post enforces, the same one behind the rules for every network. These are Hub’s input rules. Threads still judges the media itself: Hub does not download it, so file size, duration and aspect ratio are Threads’ to decide.

Hub currently refuses a mix of recognized image and video URLs in one post. That is Hub’s rule, not a claim about what Threads itself accepts. With the reels placement, Hub requires a video. Hub recognizes images and videos by the file extension in the URL; a URL without one is not type-checked, and Threads decides when it fetches the file.

Posting the same words to Instagram and Threads? Instagram allows 2,200 characters and Threads 500. Give the Threads channel its own caption in perChannel rather than shortening the post everywhere.

When validate_post refuses the post

Read ok, issues and notes in the result. The check publishes nothing and reports every problem at once, each with its field and, for a network rule, its channel. Fix them together and validate again.

Other refusals concern the request or the grant: schedule_in_past (use a future time with a UTC offset), insufficient_scope (approve a delegation with the missing permission), channel_out_of_scope (the channel is not in the grant), and at creation daily_limit_reached and idempotency_key_reused. A passing check is not proof of publication: Threads can still refuse the media or the account. The free post checker runs the same input rules on a draft before you connect anything.

Prompts you can paste

Replace the bracketed parts. Each prompt names the tools to call, so the assistant does not have to guess the order.

Check the connection, read-only

Use only Mellow Hub. Call whoami, then list_channels, then list_platforms.
Tell me my Threads channel ID, whether this connection is in review or
autopilot mode, how many posts it may still create today, and the Threads
rules. Do not create, schedule or publish anything.

A text-only post, scheduled for 09:00

Use Mellow Hub. Validate this as a text-only post for my Threads channel:
[your text]

If validate_post says it is too long, shorten it to 500 characters
or fewer without changing the meaning, and show me both versions before
continuing. Then schedule it for 09:00 on [date] in [your timezone], with
scheduledAt written with an explicit UTC offset. Call create_post once
with idempotencyKey "threads-[date]-0900", then get_post, and tell me the
Threads target's status.

One image to Instagram and Threads, each with its own caption

Use Mellow Hub. Post the image at [public https URL of a JPEG] to my
Instagram and Threads channels as one post.
Instagram caption: [longer text]
Threads caption: [up to 500 characters]

Call register_media on the image. Put the Threads caption in perChannel
under the Threads channel ID. Call validate_post and fix every issue.
Then call create_post once with idempotencyKey "image-[short-name]-1"
and call get_post. Report each target's status and link separately. If
one failed, show me its error and do not republish the one that
succeeded.

Media has to be reachable at a public https URL when Threads fetches it. An agent that can make HTTP requests, such as Claude Code or a script of your own, can instead call request_upload_url, send a local file with PUT to the returned uploadUrl and use the returned mediaUrl. An assistant that only has Hub’s tools cannot send file bytes itself.

Publish once, then read the Threads result

create_post is the step that publishes or schedules. It needs an idempotencyKey of 8 to 120 letters, digits or the characters . _ : -, stable for this post, such as threads-2026-10-02-0900. If the response is lost or times out, send the same request with the same key: Hub returns the original post instead of making a second one. Reusing a key for different content is refused.

Under a review-mode grant the post comes back as pending_review and waits until you approve it, signed in, in Hub’s Posts or Queue screen. Under autopilot it goes out at scheduledAt, or immediately without it. Always write scheduledAt with Z or an explicit UTC offset.

Then call get_post and read the Threads entry in targets, not only the post’s status. publishing means Threads has not reported a result yet; published comes with the post’s link; failed comes with the network’s message. In a post to Instagram and Threads, each target settles on its own and the post can end partial. Republish only the failed channel, with a new key; resending the whole post would duplicate the one that succeeded. Once Threads has published a post, Hub cannot edit or delete it; cancel_post works only before it goes out.

Each destination counts once against your plan: one post to Instagram and Threads is two publications. Validating, drafting and connecting work without a plan; publishing needs an active one. See plans.

What Mellow has tested with Threads

On September 20, 2026, Mellow ran an owner-approved test against the production endpoint. The official MCP Python SDK completed dynamic registration and PKCE consent for a grant limited to one Instagram and one Threads channel, autopilot, five posts a day and one day of access. A real model, Kimi K2.6, then drove the tools. On Threads alone it created a draft and cancelled it, scheduled a post, repeated the identical create request (Hub returned the same post), moved the post’s time and cancelled it. It then sent one image to Instagram and Threads in a single post, and both targets settled to published with public URLs. Publication was confirmed from each network’s result and public link, not from a screenshot.

Claude Code connected with the same grant and read the profile, permissions and channels; it did not publish. After the test the grant was revoked in Agents, and its access tokens were refused from then on.

Not tested yet: text-only, video and carousel posts to Threads, the reels placement, connecting Threads through ChatGPT’s or claude.ai’s own connector screens, and Cursor. Claude’s web connector completed Hub’s consent once, on September 9, 2026, with read-only access to an Instagram channel.

Questions

Related

• Publish to social media with an MCP server: the workflow for every network.
• Instagram MCP guide and YouTube MCP guide.
• API and MCP reference and rules for every network.
• Free post checker for a draft before you connect anything.
• Plans: each destination counts once against the monthly publications.