Threads API

Threads API for posting and scheduling without the Meta permissions puzzle

A Threads API for text, image, video, and carousel posts. Your users connect once through Threads' own login, and bundle.social runs the Meta container flow behind one request.

Built for products that need Meta text publishing and conversation-led distribution. Add Threads publishing with one API for scheduling, media, status, and reporting workflows.

Last updated: November 2026

One API keyNo per-account fees15 platformsAPI key authScheduled publishingOfficial APIs838k+ connected accountsDirect engineer support

Quick start
await fetch("https://api.bundle.social/api/v1/post", {  method: "POST",  headers: {    "x-api-key": process.env.BUNDLE_SOCIAL_API_KEY,    "Content-Type": "application/json"  },  body: JSON.stringify({    teamId: "team_123",    title: "Release notes thread",    postDate: "2026-12-01T16:00:00.000Z",    status: "SCHEDULED",    socialAccountTypes: ["THREADS"],    data: {      THREADS: {        text: "Two screens from this week's release. Which one should we write up first?",        uploadIds: ["upload_screen_1", "upload_screen_2"],        mediaItems: [{ uploadId: "upload_screen_1", altText: "Calendar view with scheduled posts" }],        topicTag: "BuildInPublic",        replyControl: "accounts_you_follow"      }    }  })});

Building directly on Meta Threads API

  • Threads uses Meta's permission and account model, so OAuth and app review still matter.
  • Scheduling Threads posts takes more than adding a publish date to a text field.
  • Teams need Threads in the same plan as Instagram, Facebook, LinkedIn, X, and other channels.

What bundle.social handles

  • Schedule Threads posts through the same API pattern used for your other social accounts.
  • Use upload IDs and media metadata for Threads content when the API supports it.
  • Connect Threads analytics and post history to broader reporting when data is available.

Threads publishing without another Meta-side quest

Threads has its own login at threads.net, its own token, and its own API host, graph.threads.net, so an Instagram connection does not carry over. bundle.social runs that OAuth flow in the hosted portal, keeps the long-lived token, and schedules Threads next to Instagram and the rest of your launch plan.

How it works

Connect accounts once, then create and schedule posts with channel-specific fields from one API.

  1. 01

    Create an API key

    Generate an organization API key in the dashboard and use it with the x-api-key header.
  2. 02

    Connect accounts

    Connect each social account once. bundle.social keeps the account mapping ready for future posts.
  3. 03

    We run the Threads container flow

    Threads follows the Meta container model: create a media container, wait for processing, then publish. Carousels need a container per item plus a parent. You send one request; bundle.social sequences the containers and reports one outcome.

Build social media workflows without rebuilding every platform

Threads API for Meta text publishing and conversation-led distribution

Demand for a Threads API comes mostly from products already publishing to Instagram and Facebook, plus the agencies and brand teams they serve. The workload is text posts, images, videos, carousel media, alt text, replies where supported, scheduling, and status tracking, all governed by Meta's account and permission model, so app review, granted scopes, and account eligibility decide what an integration can do before any post is created.

bundle.social gives Threads a production publishing workflow inside a broader social media API: scheduled posts, media attached by upload ID, and delivery status tracked next to Instagram, Facebook, LinkedIn, X, and other channels. Threads-specific limits stay visible while account connection, scheduling, and support stay shared.

Threads publishing is a Meta integration wearing a text-first interface

The Threads API looks simple from the outside (short text, optional media), but the plumbing is the Meta container model. You create a media container, wait for Meta to finish processing it, then issue a separate publish call. A carousel multiplies that: one container per item, plus a parent, each with its own processing state. Nothing about that is visible in the shape of a Threads post, which is why teams routinely underestimate it.

The second surprise is that access is governed by Meta App Review, not by having a Threads account. Until App Review grants threads_content_publish with advanced access, an app can publish only to the developer's own account and the app's testers, which makes an integration look finished long before it can serve real customers. The gap between those two states is where most Threads projects stall.

What actually fails in production

Two failure classes dominate. The first is media fetch: Meta pulls your media from a URL, so anything that makes that URL unreachable (expiring signed links, login walls, bot filtering, slow origins) surfaces as a publish failure with no obvious cause in your own logs. The second is account state: a restricted or checkpointed account rejects publishing regardless of how correct the payload is, and the fix is a user action on Instagram or Threads, not a retry.

Those two need opposite handling, and conflating them is the usual bug. A media fetch failure is worth retrying once the media is reachable. An account restriction is not retryable at all, and retrying it wastes quota and hides the real problem from the user. bundle.social classifies the failure so your product can ask the user to reconnect only when reconnecting is actually the fix.

Where Threads fits next to Instagram

Threads and Instagram share Meta's container model and most media behavior, so teams that already publish to Instagram get Threads at a fraction of the incremental cost, provided the integration is written once against a shared abstraction rather than twice against two Meta surfaces. The connection is separate: Threads has its own OAuth flow, token, and API host, so each channel is connected and reconnected on its own.

The content differs too. Threads caps posts at 500 characters, has no Reels-style video semantics, and handles replies more like a comment workflow than a post. Polls, GIFs, and link attachments work only on text-only posts, and replyControl sets who can reply.

Threads API workflows for text-first campaigns

Text posts, media references, Meta account connection, scheduling, status, and reporting context for Threads publishing.

Threads-specific payload fields

Control the fields that matter on Threads: captions, media types, privacy settings, and more, using the same post endpoint as every other channel.

API key authentication

Use one bundle.social API key for server-to-server requests. Your users still connect social accounts once through the hosted OAuth flow; bundle.social handles token storage and refresh.

Scheduling built in

Set a postDate to schedule Threads content in advance, or create drafts and queue posts through the dashboard.

Media library integration

Upload Threads-compatible media once and reference the same upload ID across multiple posts or campaigns.

Post status and retry tracking

Track Threads posts through scheduled, processing, posted, retrying, and error states from the API or the shared dashboard.

Cross-platform publishing

Add other channels to the same post payload when Threads is part of a multi-platform campaign. No separate API calls needed.

Platform specifics

Threads API constraints worth knowing before you build

Threads inherits Meta's account and permission model, so most surprises come from the platform, not from posting itself.

Threads API constraints worth knowing before you build
RuleDetails
Its own login, token, and API hostThreads authorizes at threads.net/oauth/authorize and issues a token for graph.threads.net. An Instagram token does not work there, and Meta has opened the Threads API to profiles without a linked Instagram account. A linked account matters only for crosspostToInstagramStory, which shares the post to Instagram as a Story.
Long-lived tokens last 60 daysThe authorization code becomes a short-lived token, which bundle.social exchanges for a long-lived token valid for 60 days. Meta allows a refresh once a token is at least 24 hours old, and a token not refreshed within 60 days expires for good, so the user has to connect again.
Six scopes, and publishing is only one of thembundle.social requests threads_basic, threads_content_publish, threads_manage_insights, threads_manage_replies, threads_read_replies, and threads_share_to_instagram. Publishing alone needs the first two; the rest exist so insights, replies, and Instagram Story cross-sharing do not need a second consent round later.
500 characters, and it is a hard capThreads posts are capped at 500 characters. bundle.social validates against that before the request reaches Meta, so an over-length caption fails as a validation error you can show the user rather than as a platform rejection.
Up to 10 media items, sequenced as containersA Threads post can carry up to 10 uploads. Carousels need one container per item plus a parent container, and each has to finish processing before the parent can publish.
Media is fetched from a URL, not pushedMeta pulls the media from a URL you expose, so the most common failure is a media URL that is unreachable, login-gated, or blocked to bots. bundle.social hosts the upload and serves it in a form Meta can fetch.

Developer example

Schedule a Threads post

Examples use bundle.social's public API shape: API key authentication, a post date, selected social account types, and platform-specific data.

TypeScript
await fetch("https://api.bundle.social/api/v1/post", {  method: "POST",  headers: {    "x-api-key": process.env.BUNDLE_SOCIAL_API_KEY,    "Content-Type": "application/json"  },  body: JSON.stringify({    teamId: "team_123",    title: "Release notes thread",    postDate: "2026-12-01T16:00:00.000Z",    status: "SCHEDULED",    socialAccountTypes: ["THREADS"],    data: {      THREADS: {        text: "Two screens from this week's release. Which one should we write up first?",        uploadIds: ["upload_screen_1", "upload_screen_2"],        mediaItems: [{ uploadId: "upload_screen_1", altText: "Calendar view with scheduled posts" }],        topicTag: "BuildInPublic",        replyControl: "accounts_you_follow"      }    }  })});

Supported content

  • Text posts
  • Images
  • Videos
  • Carousel media
  • Alt text
  • Replies where supported

Honest limitations

  • Threads is controlled by Meta account, permission, and API availability rules.
  • Global search, DMs, and broad discovery workflows are not the same as owned-account publishing.
  • Some reply and moderation features may require separate comment workflows.

Developer-first infrastructure

Visible post status

Track scheduled, processing, posted, retrying, and error states per post.

Verbose errors

When native APIs fail, we return human-readable error messages and actionable recovery steps.

Flat pricing

No per-post counting. Predictable pricing for teams managing many users, workspaces, and connected accounts.

Same-day support

Direct access to the engineers building the API. We respond to technical issues the same day, sometimes the same hour.

Technical guides & documentation

Questions developers ask before building

Does the Threads API use the Instagram login?

No. Threads has its own OAuth flow at threads.net and its own token for graph.threads.net, so an Instagram connection does not authorize Threads. Your users connect Threads separately through the hosted portal. Our Threads posting API tutorial covers the token flow, the 60-day refresh rule, and the two-step publish against Meta's API.

Which scopes does Threads publishing need?

bundle.social requests threads_basic, threads_content_publish, threads_manage_insights, threads_manage_replies, threads_read_replies, and threads_share_to_instagram. Publishing itself needs only the first two; the rest exist so insights and reply workflows do not require a second consent round later.

How does the container flow work for a Threads carousel?

One container per item plus a parent container, and each has to finish processing before the parent can publish. A single text post is the simple case; the carousel is where the Meta container model becomes visible.

Why does Meta fail to fetch our media?

Because Meta pulls the media from a URL you expose, so anything that makes that URL unreachable to a server-side fetcher fails the publish: expiring signed links, login walls, bot filtering, slow origins. It is the most common Threads failure and it leaves no obvious trace in your own logs.

Does this replace Meta Threads API?

No. bundle.social calls Meta Threads API for you and absorbs the work around it: token storage and refresh, media handling, scheduling, status transitions, and turning platform errors into a cause and a next action.

Are Threads analytics available through the API?

Yes, for the metrics the connected account and Meta Threads API actually expose. Availability depends on account type and granted permissions, so treat analytics as best-effort and delivery status as guaranteed.

Keep comparing your options