Automating Threads publishing with n8n and AI

Threads passed 400 million monthly active users by late 2025, driven in large part by accounts that first left X. A 2025 study by Radivojevic, Adams, Laszlo, Kery, and Weninger (University of Notre Dame), published in EPJ Data Science, User migration in the Twitter diaspora, found that it's mainly high-follower X accounts that migrate to alternative platforms — and that, unlike Mastodon or Truth Social, X follower counts correlate strongly with follower counts gained on Threads. In other words: audience really does transfer over to Threads, which makes it a channel worth feeding with the same rigor as Instagram or X — even though, as of now, there's no dedicated n8n node for it.

What the Threads API actually exposes

The Threads API (documented at developers.facebook.com/docs/threads) mirrors Instagram's Content Publishing API almost exactly, on its own domain:

• A professional Threads account is required, linked to the Meta app in use. The threads_basic scope is enabled by default; threads_content_publish must be added explicitly to publish, which means passing Meta's App Review before any production use beyond test accounts.
• A container first, then a publish call. An initial POST /{threads-user-id}/threads call creates a container with a media_type (TEXT, IMAGE, VIDEO, or CAROUSEL) and its associated content. The response returns a container id; nothing is published yet at this point.
• The container must finish processing before publishing for image and video — a GET /{container-id}?fields=status call returns IN_PROGRESS, FINISHED, ERROR, or EXPIRED.
• The actual publish step is a POST /{threads-user-id}/threads_publish call with the container's creation_id.
• A 250-post quota within a rolling 24-hour window applies per account (a carousel counts as a single post). The GET /{threads-user-id}/threads_publishing_limit endpoint returns current quota usage.
• The short-lived access token from the OAuth exchange lasts about an hour and must be exchanged for a long-lived token (roughly 60 days), which is itself refreshable before it expires.

No native n8n node covers this flow today: either the community node n8n-nodes-meta-publisher, or — the approach used here for full control over polling and errors — a series of HTTP Request nodes.

The pipeline in n8n

1. A scheduled trigger and a source of topics

A Schedule Trigger kicks off the workflow from an editorial calendar kept in Notion or Airtable, following the same principle described in our article on the multi-network editorial calendar with Notion and n8n. Each row carries a topic, a target format (text, image, carousel), and a "to process" status.

2. Draft generation via an AI Agent

An AI Agent node receives the topic along with a system prompt that sets the tone (Threads leans more conversational than Instagram, closer to a discussion thread than a showcase), a target length (500 characters max per post), and past posts as few-shot examples. Locking the output down with a Structured Output Parser (text, media_type, alt_text fields) avoids downstream formatting surprises, exactly as with the Instagram pipeline already documented on this blog.

3. Generating and publicly hosting the visual (if applicable)

For an image or carousel post, the OpenAI node (Image resource) generates the visual — see our guide on AI image generation in n8n. Just like Instagram, Threads doesn't accept a binary file as container input: it needs a publicly reachable URL (image_url or video_url), so a prior step through publicly exposed storage (an S3 bucket, a public Supabase Storage bucket) is required.

4. Human review before any API call

The draft is sent to Slack for approval, using the human-in-the-loop pattern detailed in our article on human approval with the Wait node and Slack buttons: a Wait node in On Webhook Call mode pauses the workflow until a "Publish" or "Reject" click. On a channel as fast-moving as Threads, this step remains the best safeguard against a post generated out of context on news that has already shifted by the time it would go live.

5. Creating the container, waiting, then publishing

1) POST https://graph.threads.net/v1.0/{threads-user-id}/threads
   Headers: Authorization: Bearer <access_token>
   Body: { "media_type": "TEXT", "text": "{{ $json.text }}" }
   → returns { "id": "<container_id>" }

2) GET https://graph.threads.net/v1.0/{container_id}?fields=status
   → poll (with a Wait node between each check) until status = "FINISHED"
   (unnecessary for a plain TEXT post, required for IMAGE, VIDEO, or CAROUSEL)

3) POST https://graph.threads.net/v1.0/{threads-user-id}/threads_publish
   Body: { "creation_id": "<container_id>" }

The submit-then-poll pattern is identical to any slow asynchronous API: the retry and timeout best practices apply as-is, particularly to avoid looping indefinitely on a container stuck in ERROR.

Variants: carousel and reply chains

• Carousel: first create one container per image with is_carousel_item: true, then a parent container with media_type: "CAROUSEL" and children: ["id1", "id2", ...] referencing the child containers — the same mechanics as Instagram.
• Reply chain (post thread): each following post references the previous post's id via the reply_to_id field when creating its container, which means capturing the returned identifier before chaining the next one — a job for a Loop Over Items node rather than a parallel send.
• Repurposing a blog post: the AI Agent receives the full content of an already-published article and generates a one- or multi-post summary of it, the same principle behind the repurposing flow described in our X (Twitter) guide.

Handling token renewal

The long-lived token expires after roughly 60 days. A second workflow, scheduled once a month with a Schedule Trigger, calls the refresh endpoint and replaces the value stored in the n8n credential — don't leave this task to human memory, it's the most common cause of a silent failure in this kind of pipeline (the workflow breaks a month later, with no obvious link back to the token).

Common pitfalls

• Mixing up graph.facebook.com and graph.threads.net: Threads uses its own API domain, separate from Instagram's and Facebook's — an easy copy-paste mistake between Meta pipelines when an Instagram workflow is already in place.
• Forgetting the public URL requirement: just like Instagram, a link that isn't publicly reachable causes container creation to fail, sometimes with a vague error message.
• Ignoring the 250-posts-per-24h quota: for an account managed at a high cadence, check threads_publishing_limit before firing off a burst of posts rather than discovering the limit mid-campaign.
• Letting the long-lived token expire without automated renewal: the most common and most avoidable failure in this pipeline.

Going further

The pipeline described here — scheduled trigger, AI generation, structured output, human review before action — reuses exactly the same patterns that structure the triage and drafting workflows in the Inbox AI Pack (€79), applied this time to a social channel instead of a mailbox. If you're already posting to Instagram or X with n8n, most of this pipeline — generation, Slack review, visual hosting — carries over as-is: only the API call layer changes domain and payload shape.