How-To Guide

How do you schedule Threads posts via API?

The Threads API publishes when you call it, so scheduling is a queue you run: create the container when due, publish it, refresh the token, and chain replies.

9 min read

The Threads API publishes immediately, so scheduling means running a queue on your side. Store the text or media, the target and the due time, then at the due moment create a media container, wait about 30 seconds or poll until it is ready, and publish it with creation_id. Create the container when the post is due, not days ahead, because the guides say an unpublished container expires after 24 hours. Keep a long-lived token refreshed in a daily job, since it lasts 60 days, and build a thread as a root post plus replies, each reply created with reply_to_id pointing at the post above it.

  • No publish-time parameter: the publish call takes creation_id, so the waiting happens in your store.
  • Create at fire time: the guides say a container expires after 24 hours, so an early container is wasted.
  • Two clocks: the 60-day token and the 1,000-reply cap run on their own schedules and can stop a queue quietly.

The short answer

The Threads API has no scheduling call. Publishing is two requests: create a media container, then publish it, and both run when you make them. A scheduled post is therefore a post your own system holds until the time you chose, then sends through those two calls.

That is not a limitation you can wait out with a clever parameter. Meta's publishing reference lists the publish endpoint with one specific parameter, creation_id, and the posts guide describes the calls as actions that happen now. PostGate's guide says the same in its opening: the Threads Graph API has no concept of a future publish time. PostGate

The Threads app itself can schedule a single post from the composer. PostBoost's guide reports that the feature arrived in January 2025, reaches 75 days ahead and cannot schedule replies, citing launch coverage, so check your own app for the current range. PostBoost That covers a person posting by hand. The API route below covers a program posting for an account, which brings its own queue, token lifetime and failure handling.

Five ordered queue steps: store the post, create the container, wait or poll, publish with creation_id, save the media ID. A red card says a container cannot wait days ahead because the guides say it expires after 24 hours, and a tan card says auto_publish_text skips the second call for text posts only.

Original diagram of the queue a Threads scheduler runs, with the step order taken from Meta's posts guide and publishing reference. The 24-hour expiry is drawn from Upload-Post and Threadgehog, not from a Meta sentence, and the card says so.

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.

Why a scheduled post cannot wait inside the API

Publish does one job: it takes a container and releases it. In Meta's reference, creation_id is its only endpoint-specific parameter, and the container is identified by ID alone. Publishing reference Nothing in that request names a time.

Meta's posts guide splits publishing into a create step and a publish step. The create step takes the text or a public media URL, and the publish step takes the container ID. Posts guide No draft flag and no future-time field appears in either step. That is why, as PostGate puts it, every schedule-a-Threads-post feature is a queue sitting in front of the API. PostGate

Do not try to solve it by creating containers early. Upload-Post's guide says a container expires if it is not published within 24 hours, and Threadgehog's walkthrough says the same. Upload-Post Threadgehog The 24-hour figure comes from those guides, not from a sentence on the stored Meta pages, so treat it as the working ceiling: create the container when the post is due, not the day you schedule it.

Meta also puts volume control on the caller. Its overview tells apps that allow users to schedule posts for future publishing to enforce the publishing rate limit themselves. A queue that checks the account's quota at fire time is doing the job Meta assigns it.

Run the queue at the due moment

Store the intent before you store a container: the text or media URL, the target Threads user, the due time with its timezone, and one stable job ID. The job ID is what lets a retry tell a duplicate from a fresh post, because the API has no idempotency key of its own.

At the due moment the worker runs a fixed order. Refresh the token if the job is near expiry. Create the container. Wait about 30 seconds, the pause Meta's guide recommends, and for video poll the container's status until it reports FINISHED, instead of sleeping for a guessed time. Publish with creation_id. Save the media ID that the publish call returns.

Text-only posts have a shortcut. Setting auto_publish_text publishes the post in the same call that creates the container, and Meta notes that it works only for text posts. Publishing reference Image, video and carousel posts still need the second call.

  1. Refresh the long-lived token if the job is close to its expiry.
  2. Create the media container for the text or public media URL and keep the container ID.
  3. Wait about 30 seconds, or poll the container status until it reports FINISHED for video.
  4. Publish the container with creation_id and save the media ID that comes back.
  5. Record the outcome on the job so a retry can tell a duplicate from a fresh post.

Two facts belong to the queue, not to Meta. A retry after a publish that may have succeeded has to read the saved media ID before creating a second container, since the platform will publish a duplicate if you send one. And a queued post can be edited or canceled only while your store still holds it; PostGate's docs, for example, offer PATCH and DELETE until its scheduler hands the post to Threads. PostGate

Refresh the token on a schedule of its own

The queue will outlive any single token. A short-lived token from the authorization window is valid for 1 hour, and the authorization code that produces it is also valid for 1 hour. Get started Exchange the code immediately and keep the result only long enough to exchange it again.

Keep the long-lived token; it is the one worth storing. It is valid for 60 days, and it is refreshed through GET /refresh_access_token before it expires. Get started Upload-Post's guide adds that the refresh works once the token is at least 24 hours old and still valid, which puts the safe window in the middle of the 60 days, not at the last minute. Upload-Post That age rule is the guide's reading, so keep a margin.

Run the refresh as its own daily job and store the new value. PostBoost reports refreshing a week before the 60 days are up and warning when a refresh fails, which turns a silent outage into an alert a person can act on. PostBoost

Permissions have a separate clock. A grant from a public-profile user lasts 90 days, and refreshing the long-lived token extends it for another 90 days. A grant from a private profile cannot be extended, so that user has to grant the permission again. Get started

Token ladder: auth code 1 hour, short-lived token 1 hour, long-lived token 60 days, refresh through refresh_access_token once the token is at least 24 hours old. A public-profile grant lasts 90 days and a refresh extends it; a private-profile grant cannot be extended.

Original diagram of the token and permission clocks a Threads queue has to track. The 1-hour, 60-day and 90-day figures are Meta's get-started page; the 24-hour minimum token age is Upload-Post's reading and is labelled in the figure.

Build a thread one published reply at a time

There is no thread object. Upload-Post's guide states the rule: a chain is a post plus replies to it, each created with reply_to_id set to the post above it and published separately. Upload-Post

The order matters because each step needs the ID from the one before. Publish the root post and keep the media ID it returns. Create the next container with that ID in reply_to_id, publish it, keep the new ID, and repeat. Publishing reference A queue that fires every reply at once fails at the second step, because it does not yet have the ID the reply must point at.

Replies have their own counter. Threads profiles are limited to 1,000 replies in a rolling 24-hour period, separate from the 250-post publishing cap. Overview A five-post thread is four replies, so a daily schedule across several accounts should count replies as well as posts.

If the thread is text only, auto_publish_text still saves the second call for each post, but the reply still needs the ID of the post above it, so the chain stays sequential. The shortcut shortens each step; it does not make the steps parallel.

Thread build: publish the root post and keep ID A, create reply 2 with reply_to_id=A and publish for ID B, create reply 3 with reply_to_id=B and publish for ID C, then repeat. Notes say there is no thread object and auto_publish_text works per text post only.

Original diagram of a thread as a chain of published replies, following Upload-Post's description and Meta's reply_to_id parameter. The diagram shows order, not a platform object, because the API has no thread entity.

Check the caps before the clock fires

Often the failure that stops a post is textual. Meta limits a text post to 500 characters and counts emoji as UTF-8 bytes, so a message that looks short can exceed the cap. Posts guide Validate length when the job is stored, not when it fires.

Links have their own rule. Since 22 December 2025, a post with more than five links fails during container creation with THREADS_API__LINK_LIMIT_EXCEEDED. Posts guide Changelog

LimitWhat the pages saySource
Text500 characters; emoji count as UTF-8 bytesPosts guide
Links5 per post; more fail at container creation since 22 December 2025Posts guide and changelog
Carousel2 to 20 children; counts as one postPosts guide and overview
Posts250 per profile in a rolling 24 hoursOverview
Replies1,000 per profile in a rolling 24 hoursOverview
Deletions100 per profile in a rolling 24 hoursOverview
Calls4,800 times impressions per 24 hours; impressions floor 10Overview

Read the live number before a batch. The overview documents a publishing-limit endpoint that returns quota_usage and the limit config, and the publish endpoint is where the 250 cap is enforced. A queue that stacks many posts into the same hour should read that number first.

When a container does fail, its status is one of five values: IN_PROGRESS, FINISHED, PUBLISHED, ERROR or EXPIRED. Upload-Post, following Meta's troubleshooting page, suggests checking once a minute for no more than five minutes. Upload-Post Store the error message with the job so the next run knows whether a retry is safe. If your question is what all this costs, not how it runs, the separate Threads API pricing guide covers that.

Frequently asked questions

How do you schedule Threads posts via API?

Keep the post in your own queue and call the API at the time you chose. The API publishes immediately: create a media container with the text or a public media URL, then publish it with creation_id. There is no publish-time parameter and no draft mode. Create the container when the post is due, not days ahead, because the guides say an unpublished container expires after 24 hours. Refresh the long-lived token in a daily job, since it lasts 60 days, and build a thread from a root post plus replies that each name the post above them in reply_to_id.

Does the Threads API support scheduled publishing?

No. The publish endpoint takes a container ID and nothing that names a future time, and the posts guide's two steps both act when the app calls them. PostBoost's guide states that the API has no publish-later field. Every scheduling feature is a queue the caller runs, which stores the post and makes the two calls when the time arrives.

Why can't I create the Threads container in advance?

Because the guides say it expires. Upload-Post and Threadgehog both state that a container that is not published within 24 hours expires, so a container created days ahead is gone before its slot. Create the container at publish time, wait about 30 seconds or poll until it is ready, and publish in the same run.

How long do Threads API tokens last?

An authorization code lasts 1 hour, and the short-lived token it produces also lasts 1 hour. Exchange that for a long-lived token, which is valid for 60 days and is refreshed through GET /refresh_access_token. Upload-Post reports that a refresh works once the token is at least 24 hours old. A permission grant from a public-profile user lasts 90 days and is extended by a refresh; a private-profile grant cannot be extended.

How do you build a thread with the Threads API?

Publish the root post first and keep the media ID it returns. Create the next container with that ID in reply_to_id, publish it, keep the new ID, and repeat for each reply. There is no thread object, so a thread is simply a published post plus a chain of published replies. Replies are capped at 1,000 per profile in a rolling 24-hour period.

Do scheduled Threads posts count against the 250-post cap?

The 250-post cap is enforced when the post publishes, not when you schedule it. PostGate's guide says that plainly, and Meta's overview says the publish endpoint enforces the limit. Stacking many scheduled posts into the same rolling 24-hour window can therefore hit the cap at fire time, so read the publishing-limit endpoint before a batch.

Can you schedule Threads posts without writing code?

Yes, for single posts. The Threads app has a composer scheduler that PostBoost reports reaches 75 days ahead and cannot schedule replies, so check your own app for the current range. A scheduling service with a scheduled date and timezone can also run the queue for you; Upload-Post's guide describes a scheduled date with a timezone up to 365 days ahead. If you need reply chains or a program posting for many accounts, you are back to the queue design on this page.

Related practical guides

Write the queue table before you write the worker

List the fields a job needs (text or media URL, target user, due time, timezone, job ID), then write the five-step worker against that list. Test the token refresh on its own first, because a queue that cannot refresh its token stops posting quietly at day 60.