Threads API

Threads API for posting and scheduling without the Meta permissions puzzle

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: July 2026

One API key. No per-account fees. 15 platforms.

API key authScheduled publishing15 platforms
Quick start
API request
1await fetch("https://api.bundle.social/api/v1/post", {2  method: "POST",3  headers: {4    "x-api-key": process.env.BUNDLE_SOCIAL_API_KEY,5    "Content-Type": "application/json"6  },7  body: JSON.stringify({8    teamId: "team_123",9    title: "Threads campaign",10    postDate: "2026-05-14T10:00:00.000Z",11    status: "SCHEDULED",12    socialAccountTypes: ["THREADS"],13    data: {14      THREADS: { text: "Scheduled from bundle.social." }15    }16  })17});
Official APIs500k+ connected accountsDirect engineer support

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 is conversation-led, but the setup still runs through Meta accounts, permissions, media rules, and status handling. bundle.social keeps it close to Instagram and the rest of your launch plan.

Workflow

How it works

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

01

Create an API key

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

02

Connect accounts

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

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.

Product architecture

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. In development mode you can publish to accounts you control, 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 an account graph, a permission 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 parts that genuinely differ are the character cap, the absence of Reels-style video semantics, and reply handling, which behaves more like a comment workflow than a post.

Capabilities

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.

Six scopes, and publishing is only one of them

bundle.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 and reply workflows do not require a second consent round later.

500 characters, and it is a hard cap

Threads 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 containers

A 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 pushed

Meta 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
API request
1await fetch("https://api.bundle.social/api/v1/post", {2  method: "POST",3  headers: {4    "x-api-key": process.env.BUNDLE_SOCIAL_API_KEY,5    "Content-Type": "application/json"6  },7  body: JSON.stringify({8    teamId: "team_123",9    title: "Threads campaign",10    postDate: "2026-05-14T10:00:00.000Z",11    status: "SCHEDULED",12    socialAccountTypes: ["THREADS"],13    data: {14      THREADS: { text: "Scheduled from bundle.social." }15    }16  })17});

Supported content

Text postsImagesVideosCarousel mediaAlt textReplies 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.

Guarantees

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.

Resources

Technical guides & documentation

FAQ

Questions developers ask before building

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.