“How do scheduling tools publish to Threads through the official API?”
How do scheduling tools publish to Threads through the official API?
Short answer
Scheduling tools publish to Threads through Meta's official Threads API in two calls: create a media container, then publish it, after a user grants permissions such as threads_content_publish. Meta's guide describes publish-now calls, so schedulers keep your post until the time you chose. Threadgehog hands approved posts to your scheduler, which holds the Meta app and tokens.
Steps
- 1
Create a Meta app with the Threads use case
The tool's developer registers the app in Meta's dashboard, using the Threads app ID and secret.
- 2
Get the account owner's permission
The owner approves the permissions in an authorization window. Posting needs threads_basic and threads_content_publish.
- 3
Exchange for a long-lived token
The tool swaps the short-lived token for one that lasts 60 days and refreshes it before it expires.
- 4
Create a container, wait, then publish
POST to /threads with the text or media, wait about 30 seconds, then POST to /threads_publish with the container ID.
- 5
Check status and quota
If no post ID comes back, check the container status once a minute for up to 5 minutes.
The short version
Meta publishes a Threads API under developers.facebook.com. A tool built on it needs a Meta app created with the Threads use case, permission from the account owner, and an access token. With those, it can create posts, read replies, manage replies and read insights for that account.
The posts guide describes publishing as calls that act now. A scheduler therefore keeps your post on its own side until the time you chose, then makes the two calls described below. Your post is stored in the tool, and Meta sees it only when the second call runs.
Limits such as the 500-character text cap, 250 published posts per profile per 24 hours and the link rules are covered in the Threads posting limits answer. This page covers the mechanism instead.
What a tool needs before it can post
Meta's get-started page lists the requirements. The tool needs a Meta app created with the Threads use case, and the user grants permissions in an authorization window. The permission names are threads_basic (required for all Threads endpoints), threads_content_publish (publishing endpoints only), threads_manage_replies (POST calls to reply endpoints), threads_read_replies (GET calls to reply endpoints) and threads_manage_insights (GET calls to insights endpoints).
Tokens follow OAuth 2.0 and are scoped to the app. Per the same page, an authorization code is valid for 1 hour and is exchanged for a short-lived token that lasts 1 hour. A short-lived token can be exchanged for a long-lived token that lasts 60 days and can be refreshed.
For people who have no role on the app, the page says each permission must first be approved through Meta's App Review process and the app must be published. This is why a small custom script used by its owner works sooner than a public product, and why public schedulers list Threads support only after they pass review. It also says that for users with public profiles, permission grants last 90 days, and grants from private profiles cannot be extended.
The two calls that make a post
The base address is graph.threads.net/v1.0, followed by the Threads user ID. Step one is POST /{threads-user-id}/threads with a media_type of TEXT, IMAGE or VIDEO, and the text or media URL. It returns a container ID. Step two is POST /{threads-user-id}/threads_publish with that ID as creation_id. It returns the published post's ID.
The guide recommends waiting on average 30 seconds between the two calls so the upload can finish processing. Media must sit at a public URL because Threads fetches it directly. Emojis in text are counted by their UTF-8 bytes, which matters when you are close to the 500-character cap.
Carousels take three steps: one container per item with is_carousel_item set to true, then a carousel container whose children list holds at least 2 and no more than 20 container IDs, then a publish call. The guide says a carousel counts as one post against the daily limit.
Options a scheduler can pass along
The posts guide documents a topic_tag parameter of 1 to 50 characters that cannot contain periods or ampersands, and says in-text hashtags still work but are labeled not preferred. It documents link_attachment for text posts and a gif_attachment parameter whose only provider is GIPHY. The documentation index also lists pages for polls, quote posts, reposts, spoilers, ghost posts and location tagging.
Reply controls are a separate guide: the reply_control parameter and a reply approval flow are documented there. See Threads reply controls for the options.
Checking status, quotas and errors
If a publish call returns no ID, the troubleshooting page says to check the container's status. Statuses include ERROR and EXPIRED, and a container that is not published within 24 hours expires. Meta recommends querying a container's status once per minute, for no more than 5 minutes.
The same page describes a threads_publishing_limit endpoint for checking quota before publishing. Its example response shows 250 publishes, 1000 replies, 100 deletes and 500 location searches per 86400-second window. Treat those as the example Meta gives, and read the live response for the real numbers on a given account.
These details explain failures you may see in a scheduler: a post that fails because a media URL was not public, a link-limit error, or a day when the profile hit its cap. A good tool shows the error instead of retrying silently. Ask yours which it does.
What to ask a scheduler about Threads
Questions with real answers: Does it publish through the official API or another method? Does it support text, images, video and carousels? Does it handle multi-post threads as connected posts? What is its own cap per day? Does it show errors? Does it read insights? The scheduler's own help pages answer these, and nothing here replaces them.
Threadgehog's integration guides list the schedulers it works with, for example Buffer and Postiz.
One more check: how the tool handles a token that expires. Long-lived tokens last 60 days, so a connection that stops working after two months is usually an expired token rather than a broken account. Reconnecting the profile through the tool's own settings normally fixes it, and the tool should tell you when it happens.
Where Threadgehog fits
In this flow Threadgehog is the writer. It drafts posts in your voice, waits for you to approve them in its queue, and hands approved posts to Buffer, Typefully, Publer, Metricool or Postiz on the schedule you pick, while the app is open. The scheduler holds the Meta app, the permissions and the tokens. The site is in waitlist mode, so you can join the waitlist and the 14-day free trial starts when the Mac app opens.
Questions
Is there an official Threads API?
Yes. Meta documents it at developers.facebook.com/docs/threads. It covers publishing, replies, insights and more.
Does the Threads API support scheduling?
Meta's posts guide describes publish-now calls. Schedulers hold the post themselves and publish at the time you chose.
Which permissions does posting need?
Meta lists threads_basic for all endpoints and threads_content_publish for publishing endpoints.
How long do Threads access tokens last?
Short-lived tokens last 1 hour. Long-lived tokens last 60 days and can be refreshed, per Meta's get-started page.
Do apps need review to post for other people?
Meta says each permission must be approved through App Review and the app must be published for users without a role on the app.
Does a Threads API post count toward a daily limit?
Yes. Profiles are limited to 250 published posts per 24 hours, and a carousel counts as one post.
Sources
- Meta: Threads API posts (checked 2026-10-17)
- Meta: Threads API get started (checked 2026-10-17)
- Meta: Threads API troubleshooting (checked 2026-10-17)
- Meta: Threads API reply moderation (checked 2026-10-17)
- Threadgehog pricing and FAQ (checked 2026-10-17)