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.

11 min read

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.
A decision fork from one Claude draft whose branch is who holds the Threads token: alone it stops, with a connector it publishes, with your own app you publish.

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.

Superdirector

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.

RouteSetupWho holds the tokenSchedulingWhat you pay for
Hosted MCP connectorPaste a connector URL in Claude, connect Threads in the provider's dashboardThe connector providerThe provider's own queueA subscription to the provider
Your own Threads API appMeta developer app, App Review, token refreshYouYou build the queue yourselfMeta'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.

LimitValueWhere it bites
Text length500 characters (overview; posts)A caption written for LinkedIn overruns it
EmojiCounted by UTF-8 byte count (social-api.ai)A few emoji eat far more than a few characters
Links5 or fewer (posts; changelog)A 6-link post fails at media creation since December 2025
Topic tagsOne per post (posts)Extra hashtags are ignored, not added
Posts per 24h250 per profile (overview)Only a bulk bot reaches it
Replies per 24h1,000 per profile (overview)Same
Deletions per 24h100 per profile (overview)A cleanup script hits this first
Carousel2 to 20 children (overview)A one-image carousel is invalid
ImagesJPEG or PNG (overview)A PNG export is fine; a WebP is not
VideoMOV 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.

A two-column matrix of four Threads limits and where each one breaks a post: 500 characters against a long caption, 5 links against a sixth link, 2 to 20 carousel children against a one-image carousel, and 250 posts per 24 hours that only bulk posting reaches.

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.

Frequently asked questions

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. Connect a Threads-capable MCP connector to Claude and connect your Threads account in the provider, or build a Meta app against the Threads API. Both routes run Meta's two-step publish: create a media container, then publish it.

Can Claude post to Threads without a connector?

No. Without a connector or a direct Threads API call, Claude can only write a post for you to copy. Claude has no official Threads connector, so every publishing route is third-party or built by you.

Is there an official Claude Threads connector?

No. Claude ships no official Threads connector. Connectors are either directory connectors reviewed by Anthropic or custom connectors you add by URL, and both run on the same MCP runtime. Publishing to Threads is done by a third-party server or your own app.

What are the Threads posting limits?

A text post is capped at 500 characters, 5 links or fewer, and one topic tag. A profile can publish 250 posts and 1,000 replies in a rolling 24 hours, and delete 100 posts. Images must be JPEG or PNG; video must be MOV or MP4 without edit lists, up to 300 seconds.

How long does a Threads access token last?

A short-lived Threads token lasts one hour. Exchanging it gives a long-lived token valid for 60 days, and a public-profile permission grant is valid for 90 days. A hosted connector keeps this refresh on its side, which is why you never touch a token.

Why did my Threads post fail?

The common causes are a post over 500 characters, more than 5 links, emoji counted by UTF-8 byte count pushing the text over the cap, media that is not on a public URL, or a media container that expired after 24 hours before it was published. Check those before you blame the model.

Related practical guides

Choose where the token lives

Pick the connector route if you want to post this week, or the API route if Threads is the product. Either way, keep the 500-character cap and the five-link rule in view before your first post.