How-To Guide
How do you post to Threads with Claude?
Claude has no native Threads posting. Connect a Threads MCP connector or call Meta's Threads API: a two-step publish, 500-character posts and 250 a day.
By the Superdirector editorial team. Meta's Threads developer documentation and Anthropic's Claude connector documentation read November 14, 2026; three competitor guides on posting to Threads with Claude read November 15, 2026; revised November 15, 2026.
At a glance
How do you post to Threads with Claude?
Claude cannot publish to Threads on its own; it writes the post and something else sends it. Either connect a Threads-capable MCP connector to Claude, which holds the token and publishes for you, or build a Meta app against the Threads API yourself. Both run Meta's two-step publish: create a media container, then publish it. Every Threads limit still applies, including 500 characters per post, five links or fewer, and 250 posts in 24 hours.
- Claude has no official Threads connector; on its own it only writes a post to copy.
- Route one: add a connector that publishes to Threads, connect the account in the provider, and ask Claude to list the account before posting.
- Route two: register a Meta app, clear App Review, manage a 60-day token, then create and publish a media container.
- The limits are Meta's: 500 characters, 5 links or fewer, one topic tag, 250 posts and 1,000 replies per 24 hours.
- Scheduling and threaded chains live in the provider's queue; the Threads API has no scheduling endpoint and no DM endpoint.
The three states the section names: Claude alone drafts and stops, a connector holds the token and publishes, and your own app holds the token while you publish. Both publishing routes run Meta's create-then-publish calls underneath. Original diagram from the Claude Help Center connector page and Meta's Threads posts page read November 14, 2026.
Make it work for your brand
Find it. Remake it. Post it. Superdirector turns the viral formats in your niche into your brand's carousels, X posts and video scripts, and keeps the calendar full.
The short answer: Claude drafts, a connector or the Threads API publishes
Claude cannot publish to Threads by itself. Out of the box it writes a Threads post for you to copy, and that is the whole of its Threads ability: Claude ships no official Threads connector, and at least one competitor guide says the same (PostHero). To get a post onto Threads, something else has to hold a Threads access token and send it. You have two ways to put that something between Claude and Threads.
The first way is to connect a hosted MCP connector. You paste a connector address into Claude, connect your Threads account through Threads' own login, and from then on you can ask Claude in plain language to publish. You never build a Meta developer app, and the provider keeps the token. The second way is to build against the Threads API yourself. You register a Meta app, clear App Review, hold the token and call Meta's endpoints. It is more work and more control.
Either route ends in the same Meta step. The Threads API publishes a post as one of two calls: first you create a media container, then you publish that container (Meta's posts page). Nothing in either route changes that, because the connector is calling the same endpoints you would.
| Route | Setup | Who holds the token | Scheduling | What you pay for |
|---|---|---|---|---|
| Hosted MCP connector | Paste a connector URL in Claude, connect Threads in the provider's dashboard | The connector provider | The provider's own queue | A subscription to the provider |
| Your own Threads API app | Meta developer app, App Review, token refresh | You | You build the queue yourself | Meta's developer pages publish no price; you pay in your own time |
Everything below applies to both routes: the two-step publish, the character limit, the daily caps and the media rules are Meta's, not the provider's. A connector can make the setup shorter, but it cannot lift a single Threads limit.
Know the boundary: what Claude can and cannot do on Threads
The Model Context Protocol is the piece that makes any of this possible. Anthropic describes it as "an open standard, created by Anthropic, for AI applications to connect to tools and data" (Claude Help Center). A connector is how Claude reaches a remote MCP server that publishes on your behalf.
Custom connectors work on Claude, Cowork and Claude Desktop across the Free through Enterprise plans, and a Free plan is limited to one custom connector (Claude Help Center). That is enough for a single Threads account. The connection does not come from your laptop: Claude reaches the server from Anthropic's cloud, so the server has to be public on HTTPS port 443 (Claude Help Center). A connector you cannot reach from the open internet will not work, however well it runs on your desk.
Two connector types look different to a buyer but behave the same once connected. A directory connector is a reviewed server Anthropic lists; a custom connector is one you add by URL. Anthropic's own comparison says both run "on the same MCP infrastructure: the runtime, transport, authentication, and tool-calling code paths are identical" (directory vs custom). The practical difference is discoverability and who reviewed it, not what Claude can do with it.
So the boundary is not about which connector you pick. It is about where the token sits:
- Claude, alone: drafts the text and stops. There is no posting action to run.
- Claude plus a connector: the connector holds your Threads token and runs the two Meta calls; Claude calls the connector's publish tool.
- You plus the Threads API: your own app holds the token and makes the calls; Claude is only useful for writing the copy you paste into your tool.
Route one: connect a Threads MCP connector to Claude
This is the route most people want, because it turns a Meta developer chore into a few clicks inside Claude. The shape is the same for any provider that publishes to Threads; the steps below are the generic ones the competitor guides and Anthropic's connector docs agree on.
- Pick a connector that actually publishes. Some servers only read Threads data. PostHero's comparison marks which tools publish and which only read, and notes that "Claude has no official Threads connector" (PostHero). Check the provider's own page before you connect.
- Connect your Threads account in the provider. You log in to Threads on Threads' own screen and approve access; Claude never sees your password. Blotato calls this the step that lets Claude publish later with no OAuth on your machine (Blotato).
- Add the connector in Claude. In Claude, open Settings, then Connectors, and add a custom connector by pasting the server address the provider gives you. If the provider is in Anthropic's directory, you can add it from the directory instead. Both end at the same runtime (directory vs custom).
- Confirm the account is visible. Ask Claude to list the connected accounts. If Threads is missing, re-authorize it in the provider. A missing account is the most common reason a first post never arrives.
- Ask in plain language. Tell Claude what to post and where. The connector translates that into the provider's publish call, which runs Meta's two calls underneath.
On a Team or Enterprise plan, an Owner or Primary Owner adds the connector to the organization first, and on Enterprise a custom role with Manage access to Libraries can add it too; individual members then connect and enable it for themselves (Claude Help Center). On a personal plan there is no such gate, and the Free plan's one-connector limit is the only cap.
The trade is control for speed. You do not register a Meta app, you do not refresh a 60-day token, and you do not clear App Review, because the provider already did all three on its side (Blotato). In exchange, the provider holds your token, and its queue decides how scheduling works.
Route two: publish with the Threads API yourself
Building it yourself means you own the token and the publish call. It is the route to choose when you want one platform under your own control, or when you are building a tool rather than running an account. Meta's developer pages lay the path out in order.
First you register a Meta app and request the Threads permissions you need. Production posting is gated: Meta says "each permission must first be approved through the App Review" (get-started). Until then you can post only as a test user.
Then you manage tokens. A short-lived Threads token lasts one hour; exchanging it gives a long-lived token valid for 60 days (get-started). A public-profile permission grant lasts 90 days (get-started). Build the refresh into your job, or posting stops silently on day 60.
Publishing is two calls. Meta's posts page states it as a two-step process: create a media container with your text, then publish that container (posts). For a media post the file must sit on a publicly accessible server at the moment of the call (get-started). Meta also tells you to "wait about 30 seconds before publishing a Threads media container" so the upload can finish processing (posts). An unpublished container expires after 24 hours, so a slow queue can lose a post before it goes out (social-api.ai).
One 2025 change removed a common blocker: the Threads API is now open to profiles without a linked Instagram account (changelog). You no longer need an Instagram presence to publish to Threads through the API.
The direct API is what a connector is doing for you. Every fact above is a Meta rule the connector obeys, which is why a connector cannot promise a behaviour the API does not have.
The limits that break a Threads post
Most failed Threads posts fail on a limit, not on a model mistake. These are the numbers that matter, all from Meta's own pages.
| Limit | Value | Where it bites |
|---|---|---|
| Text length | 500 characters (overview; posts) | A caption written for LinkedIn overruns it |
| Emoji | Counted by UTF-8 byte count (social-api.ai) | A few emoji eat far more than a few characters |
| Links | 5 or fewer (posts; changelog) | A 6-link post fails at media creation since December 2025 |
| Topic tags | One per post (posts) | Extra hashtags are ignored, not added |
| Posts per 24h | 250 per profile (overview) | Only a bulk bot reaches it |
| Replies per 24h | 1,000 per profile (overview) | Same |
| Deletions per 24h | 100 per profile (overview) | A cleanup script hits this first |
| Carousel | 2 to 20 children (overview) | A one-image carousel is invalid |
| Images | JPEG or PNG (overview) | A PNG export is fine; a WebP is not |
| Video | MOV or MP4, no edit lists, 300 seconds max (overview) | A trimmed phone clip can carry edit lists |
Two more rules sit outside the table. A post that discloses AI-generated content sets is_made_with_ai=true on the container, and Meta then shows an AI info label (posts). That is a disclosure you choose, not a penalty. And a carousel counts as one post against the 250 cap, which is why a 20-image carousel is cheaper on the cap than 20 single posts.
Each ceiling names the failure it causes: a caption over 500 characters, a sixth link at media creation, a one-image carousel, and a day's 250 posts that only bulk posting reaches. Original diagram from Meta's Threads overview, posts and changelog pages read November 14, 2026.
Scheduling, threads and images
Threads has no scheduling in the API. The developer guide puts it plainly: the API "has no scheduling parameter or endpoint" (social-api.ai). So when a connector says it can schedule a Threads post, the scheduling lives in the connector's own queue; the post is held there and sent at the planned minute. That is a real feature, but it is the provider's, not Threads'.
The same is true of direct messages. There is no DM endpoint in the Threads API (social-api.ai), so a tool that promises Threads DMs is either not using the API for them or is overstating what it does.
Chaining several posts into one thread is a connector feature too. Blotato describes adding follow-up posts so they thread together in a single call (Blotato). Meta's posts page documents single posts and carousels; treat a threaded chain as the provider's plumbing on top of repeated single posts, and check that the provider supports it before you rely on it.
Images follow the same upload rule in both routes. The connector or your app needs the media on a public URL when it publishes (get-started). A hosted connector usually gives you a media library to upload into first, which is why a screenshot pasted into chat does not always reach Threads.
Which route to choose
For most people who already write in Claude, the hosted connector is the right first move. It is minutes rather than days, it skips the Meta developer app and App Review, and one connection usually covers Threads and your other networks (Blotato). You give up control of the token and depend on the provider's queue, which is a fair trade when you are running one or two accounts.
Build it yourself when Threads is the product, when you need the token under your own control, or when a connector's limits get in the way. You will spend the time on a Meta app, App Review and a 60-day refresh, and you get to decide exactly what a post contains. Meta's developer pages publish no price for the API itself; the cost is your engineering time (Blotato pricing).
Superdirector sits on the connector side of that line. The $29 a month plan connects Superdirector's MCP to Claude for finding, drafting and hands-on creation. The $199 a month plan runs one AI-operated social account that publishes eligible Instagram carousels and single link-free X text posts on a schedule, with posting turned on once at the account level as a standing permission, not re-approved for every post (pricing). Neither plan posts to Threads, and neither gives Claude a native Threads button; a Threads token stays with a connector, the same boundary every route here shares.
Whichever route you pick, the limits in the section above still apply. A connector saves you the Meta setup; it does not save you the 500-character cap, the five-link rule or the public-media requirement. Write for Threads first, then let the tool publish.