How to Automate Threads Posts with n8n: A Threads API Tutorial

Tired of publishing every Threads post manually? By connecting n8n to the Threads API, you can turn scheduling, post creation, and publishing into one automated workflow. If API integrations and unfamiliar AI tools sound complicated, don’t worry. This Threads automation guide is based on a workflow we tested ourselves. We’ll start with the Threads API, Threads Access Token, and basic n8n setup, then walk through four steps to automate Threads posts so you can understand how the workflow actually works.

If you want to compare other ways to schedule or automate Threads posts first, see: Threads Scheduler Guide: How to Schedule Threads Posts + 5 Automation Tools

The basic idea behind n8n Threads automation is simple: n8n controls the workflow, while the official Threads API handles post creation and publishing. Unlike using Threads’ built-in scheduler alone, n8n can trigger actions based on specific conditions, pull content from other data sources, and connect multiple steps in sequence. This makes it useful for teams that want to build a more flexible social media management workflow. A basic Threads automation flow can be built with three nodes:

1. Schedule Trigger

2. Create Threads Post

3. Publish Threads Post

The Schedule Trigger decides when the workflow starts. Create Threads Post then sends your content to the Threads API and creates a post container. Once that step succeeds, it returns an id. Publish Threads Post uses that id as the creation_id and sends it to the publishing endpoint, which publishes the post to your Threads account.

In the workflow demonstrated in this Threads API tutorial, post creation and publishing are handled as two separate steps. That is why we use two HTTP Request nodes in n8n: the first prepares the content, and the second publishes it. Once you understand this structure, you can extend the same workflow with scheduling, AI-generated content, or other content marketing automation.

Before you automate Threads posts with n8n, prepare three things: access to the Threads API, a valid Threads Access Token for the account you want to use, and a working n8n environment. These handle API access, account authorization, and workflow execution respectively. It is worth confirming all three before setting up the HTTP Requests, because this makes troubleshooting much easier later.

For more AI workflow automation tools, see: 9 Best AI Automation Tools in 2026: Zapier, Make, n8n, and More

Threads API

The Threads API is the interface n8n uses to communicate with Threads. A normal Threads profile URL such as threads.com/@username is designed for people viewing a profile. You cannot simply paste that profile URL into n8n and use it to publish posts. To automate Threads posts, n8n needs to call Meta’s Threads API endpoints instead. The setup may look complicated if you have never worked with an API before, but the initial preparation can be summarized in three steps:

1. Create and configure a Meta app

2. Add a Threads test account

3. Accept the tester invitation from Threads

First, sign in to Meta for Developers and create a new app. When selecting a use case, choose the option for accessing the Threads API. Continue through the setup screens and open the app dashboard once the app has been created.

Next, configure the Threads account and permissions you will use for testing. Because this tutorial focuses on creating and publishing posts, open the Threads API use case and enable the basic permissions needed for this workflow: threads_basic and threads_content_publish.

Once both permissions are available, open the settings area and add a user for testing. This lets you designate a Threads account that can be used with the app while you test your n8n Threads API workflow.

After adding the account, open the specified Threads account and check the Apps and Websites section for the invitation. Accept it, then return to Meta for Developers and refresh the dashboard. Once the account appears correctly, your test account is ready.

*Tip: For your first test, use an account where publishing test posts will not cause problems. Avoid testing on an important production account unless temporary test content is acceptable.*

Threads Access Token

A Threads Access Token is an authorization credential that tells Meta your app is allowed to perform actions for a specific Threads account. When you connect the Threads API to n8n, you need both the Threads User ID and an Access Token. Without the token, Threads cannot verify that the API request is authorized. The process can be broken into three simple steps:

1. Open the Graph API Explorer

2. Grant access permissions

3. Submit the request

From the testing section in Meta for Developers, locate the Graph API Explorer and open it.

In Graph API Explorer, switch the domain after “graph” to threads.net/. Then select the Meta app you created earlier. Click “Generate Threads Access Token” and approve the requested access permissions.

Once you confirm the correct account, you can obtain the Threads Access Token. Before moving on to n8n, use the token to check your Threads ID as well. This confirms that the token, account, and basic permissions are connected correctly. Submit the request and make sure the Threads User ID and account information are returned successfully.

Keep in mind that a Threads Access Token is not your Threads password, and it is not an API key you get by clicking “copy” on the API documentation page. It must be generated through Meta’s authorization process. Tokens also expire. Even a long-lived Threads Access Token currently lasts about 60 days, so if an existing Threads automation suddenly starts returning authorization errors, check whether the Threads API Token has expired. The FAQ later in this guide explains how to exchange a short-lived token for a long-lived token and refresh it before expiration.

n8n setup

In this workflow, n8n controls when each action runs and in what order. You can use n8n Cloud or a self-hosted n8n installation. Creating workflows and using HTTP Request nodes works similarly in both environments, although sign-in, external service authorization, and infrastructure management may differ.

For the n8n Threads API workflow in this guide, you do not need to install a separate Threads package or build a full automation program from scratch. You only need a working n8n environment where you can create a Workflow. In the next section, we will use a Trigger to control execution and HTTP Request nodes to connect to the Threads API.

This tutorial uses two basic node types:

• Trigger: decides when the workflow starts.

• HTTP Request: sends content to the Threads API and runs the post creation and publishing requests.

For your first test, start with a plain-text post. Once the basic Threads API workflow works correctly, you can add scheduling and more advanced automation without having to troubleshoot several moving parts at once.

Once your Threads API, Access Token, and n8n environment are ready, you can build the actual automation. We will start with the simplest text-only workflow: trigger the workflow, create the post, and publish it. After the manual test succeeds, we will switch the trigger to an automated schedule.

1. Create an n8n Workflow

Create a new Workflow and start with a Manual Trigger. Using a Manual Trigger during your first test gives you full control over when the workflow runs and prevents unfinished settings from repeatedly publishing test posts.

Next, add two HTTP Request nodes after the Manual Trigger. n8n does not provide built-in nodes named “Create Threads Post” or “Publish Threads Post” for this workflow, so search for “HTTP Request” and add it twice. To make the workflow easier to understand, rename the first node “Create Threads Post” and the second “Publish Threads Post.”

The first HTTP Request creates the post content, while the second publishes it. Separating the names also makes later expressions and troubleshooting easier to follow.

2. Prepare the Threads post content

Open the first “Create Threads Post” node and set the HTTP Method to “POST.” Use the following URL: https://graph.threads.net/v1.0/{Threads User ID}/threads. Replace {Threads User ID} with the ID you obtained from Meta for Developers. Do not use your Threads profile URL or @username here.

Turn on “Send Query Parameters” and add these three parameters:

1. media_type = TEXT

2. text = the Threads post you want to publish

3. access_token = Threads Access Token

The value in the text field is what will ultimately appear on Threads. If you simply want to publish a different post later, the easiest approach is to change this field. You do not need to edit the Publish node. Once the parameters are ready, click “Execute steps” to test the node.

At this point, the post will not yet be visible on your Threads profile. The next node handles the actual publishing step.

3. Connect the Threads API and publish the post

Open the second “Publish Threads Post” node and set the HTTP Method to “POST” again. This time, use https://graph.threads.net/v1.0/{Threads User ID}/threads_publish. This request mainly requires two parameters:

• creation_id

• access_token

The creation_id should come from the id returned by the previous “Create Threads Post” node. Do not manually paste a fixed id, because the next Workflow execution would otherwise keep using old data. Instead, switch creation_id to an Expression and enter {{ $('Create Threads Post').item.json.id }}.

If your workflow is as simple as this example, with no extra nodes between Create and Publish, you can also use {{ $json.id }}. We used this shorter version during our own test. In practice, both approaches tell n8n to take the id generated during the current Create Threads Post execution and pass it to the Publish node.

Once this step succeeds, the basic n8n Threads API connection is working. Open your Threads account and confirm that the post has actually been published.

4. Test the workflow and switch to automatic publishing

After confirming the test post was published correctly, replace the Manual Trigger with a Schedule Trigger. This turns your workflow into a real n8n Threads automation, so you no longer have to run it manually each time.

Open the menu on the existing Manual Trigger node, choose “Replace,” search for “Schedule Trigger,” and select it. The two HTTP Request nodes that follow can stay exactly as they are.

Open the Schedule Trigger node and choose the time or interval you want the Workflow to run. For the first test, use a time close to the present so you can quickly confirm the trigger is working. For example, you could temporarily run it every five minutes to verify that n8n starts automatically without clicking Execute.

After setting the schedule, remember to click “Publish.”

If the Schedule Trigger runs automatically at the configured time and the new post appears on Threads, your basic n8n Threads automation is complete. You will also have less need to manually remember the best times to post on Threads each day.

Advanced n8n Threads automation ideas

If you do not want to manually edit the text field every time, you can extend the Workflow by pulling content from Google Sheets, Notion, or an AI node. This lets Threads automation handle more than scheduling alone, including content sourcing, AI-generated drafts, and post-publishing records.

1. Add AI topic selection and post generation: Place an AI node before Create Threads Post, generate a Threads draft from a chosen topic, and pass the result dynamically into the text parameter. You can also add trend research or predefined content directions to create a workflow such as “topic selection → AI-generated post → Threads API publishing.” This is one way to turn a basic Threads workflow into a broader AI workflow automation.

2. Manage pending posts with Google Sheets: Instead of opening n8n every time you need to change the text field, store post copy, scheduled times, and publishing status in Google Sheets. n8n can then retrieve pending rows and pass the content into the Threads workflow, allowing social media teams to manage upcoming posts from one spreadsheet.

3. Record results and send notifications: Add nodes after Publish Threads Post to write publishing times, status, or results back to Google Sheets. You can also send Slack or email notifications so your team knows whether each automation run succeeded and can troubleshoot errors more quickly.

These advanced options do not change the core process of creating the post, retrieving its id, and publishing it. They simply add more steps before or after the basic n8n Threads API workflow.

Is the Threads API free?

The Threads API is not priced on a “per post” basis. Simply using the official API to create and publish Threads posts does not add a separate per-post fee like some third-party scheduling platforms do. However, your overall automation stack may still have costs. For example, n8n Cloud may require a paid plan, a self-hosted n8n instance needs server resources, and AI models or other third-party services may have their own usage fees. Some setup options can also depend on your account status, so check the requirements for your own environment before building the workflow.

Does a Threads Access Token expire?

Yes. The initial Threads User Access Token is a short-lived token and is suitable for testing. If you plan to run n8n Threads automation over a longer period, it is better to exchange it for a long-lived token. A long-lived Threads Access Token currently lasts about 60 days. Meta also provides endpoints for exchanging short-lived tokens and refreshing long-lived tokens.

To exchange a short-lived token for a long-lived token, use:

https://graph.threads.net/access_token

?grant_type=th_exchange_token

&client_secret=your App Secret

&access_token=your short-lived Access Token

If the request succeeds, Meta returns a new access_token and expires_in value. The resulting long-lived token can be used in n8n for ongoing workflows and is valid for roughly 60 days.

Before that long-lived token expires, you can refresh it with:

https://graph.threads.net/refresh_access_token

?grant_type=th_refresh_token

&access_token=your current valid long-lived Access Token

A successful refresh extends the token validity for roughly another 60 days. You must refresh the long-lived token before it expires. Once the token has already expired, you cannot restore it with the refresh endpoint. If you miss the renewal window, you will need to go through the authorization flow again, obtain a new short-lived token, and exchange it for a long-lived token.

This is especially important for long-running automation. If a previously working workflow suddenly starts returning authorization errors, token expiration should be one of the first things you check.

Can n8n automatically post to Threads?

Yes. n8n does not log directly into your Threads account and click the Publish button. Instead, HTTP Request nodes call the official Threads API. The basic workflow tested in this guide uses one Trigger and two HTTP Request nodes. As long as the Threads User ID, Access Token, and API parameters are configured correctly, a Schedule Trigger can run the workflow and automate Threads posts at the times you choose.

Can I set this up without knowing how to code?

Yes. You do not need to build a full automated posting program from scratch, but it helps to understand basic API concepts such as URLs, Access Tokens, Query Parameters, and n8n Expressions. Most of the setup happens in n8n’s visual interface: you add nodes, enter parameters, and pass data from one node to the next.

So even if you do not have a programming background, you can follow the workflow. Just expect to spend a little time learning how API data moves between n8n nodes during your first setup.

Can the Threads API publish images?

Yes. When creating a post with the Threads API, media_type can be set to TEXT, IMAGE, VIDEO, or CAROUSEL. To publish an image, change media_type to IMAGE and provide an image_url. Video posts require a video_url.

For your first n8n Threads API test, however, we recommend starting with plain text. It has fewer parameters and makes it easier to tell whether an error comes from the Threads Access Token, API request, or n8n Workflow. Once text publishing works correctly, you can add images or videos without having to troubleshoot several variables at the same time.

Connecting n8n to the Threads API gives you plenty of flexibility, but you still need to manage the Threads Access Token, HTTP Requests, and scheduling logic yourself. If your goal is simply to create and publish Threads content faster, GenApe brings trend discovery, AI post generation, content review, and publishing into one workflow. This reduces the effort required to maintain a custom automation setup. If you would rather spend less time configuring APIs and nodes, use GenApe to build a simpler Threads content workflow.