How to Post to Threads via API (2026 Guide)

Threads hit 300 million monthly active users in late 2025 and the developer ecosystem is finally catching up. If you are building a tool, an agent, or an internal workflow that needs to post to Threads programmatically, you have two options: the native Threads API (a subset of Meta's Graph API) or a unified API like PostEverywhere's.

This guide walks through both approaches — authentication, endpoints, content types, rate limits, and the practical trade-offs. I will keep it direct and code-first.

Table of Contents

1. Why Post to Threads via API?
2. Option 1: The Native Threads API
3. Threads API Authentication
4. Creating a Text Post
5. Posting Images and Videos
6. Carousel Posts
7. Native API Limitations
8. Option 2: PostEverywhere's Unified API
9. Comparison: Native Threads API vs PostEverywhere API
10. Threads API vs Instagram API
11. FAQs

Why Post to Threads via API?

If you are managing more than one Threads account, or you need to publish content at scale, the Threads app and web interface are not going to cut it. Common use cases:

• SaaS products that include social publishing as a feature
• AI agents that generate and distribute content across platforms
• Agencies scheduling Threads posts alongside Instagram, X, and LinkedIn
• Marketing teams integrating Threads into their content pipeline
• Developers building cross-posting workflows that publish once and distribute everywhere

The Threads API launched in mid-2024 and has been steadily expanding. It is functional — but it has sharp edges that you need to know about before you commit to a direct integration.

Option 1: The Native Threads API

The Threads API is built on top of Meta's Graph API. If you have worked with the Instagram Graph API or the Facebook Pages API, the patterns will feel familiar — but the Threads API has its own authentication flow, its own permissions, and its own quirks.

Threads API Authentication

Threads authentication runs through Instagram. Your users need an Instagram Business or Creator account linked to their Threads profile. Here is the flow:

1. Create a Meta App — register at developers.facebook.com and add the Threads use case
2. Request permissions — you need threads_basic and threads_content_publish scopes
3. OAuth 2.0 authorization — redirect users to the Threads authorization URL
4. Exchange the code for a token — standard OAuth code exchange

The authorization URL looks like this:

https://threads.net/oauth/authorize
  ?client_id=YOUR_APP_ID
  &redirect_uri=YOUR_REDIRECT_URI
  &scope=threads_basic,threads_content_publish
  &response_type=code

Once you have the authorization code, exchange it for a short-lived token:

curl -X POST "https://graph.threads.net/oauth/access_token" \
  -d "client_id=YOUR_APP_ID" \
  -d "client_secret=YOUR_APP_SECRET" \
  -d "grant_type=authorization_code" \
  -d "redirect_uri=YOUR_REDIRECT_URI" \
  -d "code=AUTH_CODE"

Short-lived tokens expire after one hour. Exchange them for long-lived tokens (60 days) using the token exchange endpoint:

curl -X GET "https://graph.threads.net/access_token\
?grant_type=th_exchange_token\
&client_secret=YOUR_APP_SECRET\
&access_token=SHORT_LIVED_TOKEN"

You will need to build a refresh flow to keep tokens alive. This is identical to the Instagram token lifecycle, but uses separate endpoints.

Creating a Text Post

Threads publishing follows the same two-step container pattern as Instagram. First you create a media container, then you publish it.

Step 1: Create a media container

curl -X POST "https://graph.threads.net/v1.0/USER_ID/threads" \
  -d "media_type=TEXT" \
  -d "text=Shipping a new feature today. Full details on our blog." \
  -d "access_token=YOUR_ACCESS_TOKEN"

This returns a creation_id.

Step 2: Publish the container

curl -X POST "https://graph.threads.net/v1.0/USER_ID/threads_publish" \
  -d "creation_id=CONTAINER_ID" \
  -d "access_token=YOUR_ACCESS_TOKEN"

That is it for a basic text post. The text field supports up to 500 characters, and you can include URLs which Threads will auto-preview.

Posting Images and Videos

For image posts, swap the media_type and add an image_url parameter:

curl -X POST "https://graph.threads.net/v1.0/USER_ID/threads" \
  -d "media_type=IMAGE" \
  -d "image_url=https://example.com/image.jpg" \
  -d "text=Our latest product shot." \
  -d "access_token=YOUR_ACCESS_TOKEN"

For video posts, use media_type=VIDEO and provide a video_url:

curl -X POST "https://graph.threads.net/v1.0/USER_ID/threads" \
  -d "media_type=VIDEO" \
  -d "video_url=https://example.com/video.mp4" \
  -d "text=Quick demo of the new dashboard." \
  -d "access_token=YOUR_ACCESS_TOKEN"

Video processing is asynchronous. After creating the container, you need to poll the container status endpoint until it returns FINISHED before you can publish:

curl -X GET "https://graph.threads.net/v1.0/CONTAINER_ID\
?fields=status\
&access_token=YOUR_ACCESS_TOKEN"

Supported image formats are JPEG and PNG. Videos must be MP4 (H.264), under 5 minutes, and smaller than 1 GB.

Carousel Posts

Threads supports carousel posts with up to 20 items (images, videos, or a mix). The flow is more involved:

Step 1: Create individual item containers

curl -X POST "https://graph.threads.net/v1.0/USER_ID/threads" \
  -d "media_type=IMAGE" \
  -d "image_url=https://example.com/slide1.jpg" \
  -d "is_carousel_item=true" \
  -d "access_token=YOUR_ACCESS_TOKEN"

Repeat for each item and collect the creation_id values.

Step 2: Create the carousel container

curl -X POST "https://graph.threads.net/v1.0/USER_ID/threads" \
  -d "media_type=CAROUSEL" \
  -d "children=ID_1,ID_2,ID_3" \
  -d "text=Three things we shipped this week." \
  -d "access_token=YOUR_ACCESS_TOKEN"

Step 3: Publish

curl -X POST "https://graph.threads.net/v1.0/USER_ID/threads_publish" \
  -d "creation_id=CAROUSEL_CONTAINER_ID" \
  -d "access_token=YOUR_ACCESS_TOKEN"

For a 10-image carousel, that is 12 API calls minimum — one for each item, one for the carousel container, and one to publish.

Native API Limitations

Before you build a full integration against the native Threads API, here are the constraints you should know:

• No native scheduling — the Threads API publishes immediately. There is no scheduled_at parameter. If you need to schedule posts, you must build your own queue and cron system
• No editing — once published, posts cannot be edited via the API
• No reply threading via the publishing endpoint — you cannot programmatically create threaded replies (multi-post threads) through the content publishing API
• Rate limits — the Threads API shares rate limits with the Meta Graph API pool. The publishing limit is 250 posts per 24-hour period per user
• Media must be publicly accessible — image and video URLs must be publicly reachable. You cannot upload directly; the API fetches from the URL you provide
• App review required — your Meta app must pass review to use threads_content_publish in production
• Token management — tokens expire every 60 days and require refresh logic

For a simple "post once in a while" use case, the native API works. For anything production-grade — scheduling, multi-account management, cross-platform publishing — the overhead adds up fast.

Building a Threads integration? PostEverywhere's API handles authentication, scheduling, and publishing across Threads and seven other platforms in a single request. See the developer docs.

Option 2: PostEverywhere's Unified API

If you need scheduling, cross-platform publishing, or you simply do not want to maintain Meta's OAuth flow and token refresh logic, a unified API is the practical choice.

PostEverywhere's REST API lets you post to Threads — alongside Instagram, Facebook, LinkedIn, X, TikTok, YouTube, and Pinterest — with a single endpoint. Here is what that looks like:

Schedule a Threads post:

curl -X POST "https://app.posteverywhere.ai/api/v1/posts" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Shipping a new feature today. Full details on our blog.",
    "platforms": ["threads"],
    "scheduled_at": "2026-04-15T14:00:00Z"
  }'

That is one request. No container creation. No two-step publish flow. No token refresh logic on your end. PostEverywhere handles the Meta OAuth lifecycle, the container creation, and the publishing at the scheduled time.

Cross-post to Threads and Instagram simultaneously:

curl -X POST "https://app.posteverywhere.ai/api/v1/posts" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "New product update — check the link in bio for details.",
    "platforms": ["threads", "instagram", "facebook"],
    "media_url": "https://example.com/image.jpg",
    "scheduled_at": "2026-04-15T14:00:00Z"
  }'

Since Threads and Instagram both sit on Meta's infrastructure, cross-posting between them is a natural workflow. PostEverywhere's API handles the format differences — Instagram requires an image or video, Threads allows text-only — and adjusts automatically based on the content you provide.

For the full API reference, including media uploads, webhook callbacks, and AI content generation, check the developer documentation.

Why This Matters for Developers

The native Threads API is fine for a single-platform, single-account prototype. But if you are building something that ships to users — an agency tool, a scheduling product, a social media automation workflow — you will spend more time maintaining the integration than building your actual product.

PostEverywhere's API gives you:

• One authentication method — API key, no OAuth flows to manage
• Built-in scheduling — set a future timestamp, the API handles the rest
• Media handling — presigned uploads with automatic format conversion
• Rate limit abstraction — 60 requests/minute, 10,000/day across all platforms
• AI content generation — generate Threads-optimized captions via the API
• Webhook callbacks — get notified when posts publish successfully or fail

Ready to integrate Threads into your product? PostEverywhere's API is free to test — no credit card required. Get your API key.

Comparison: Native Threads API vs PostEverywhere API

If your requirements are simple — occasional text posts to a single Threads account — the native API is free and functional. For everything else, the unified approach saves significant development and maintenance time.

Threads API vs Instagram API

Developers often ask whether the Threads API and Instagram API are the same thing. They are not, but they are closely related.

What they share:

• Both use Meta's Graph API infrastructure
• Both require a Meta developer app
• Both follow the OAuth 2.0 authorization flow
• Both use the container-based publishing model (create container, then publish)
• Both require app review for production use

Where they differ:

• Separate access tokens — a Threads token does not work for Instagram and vice versa. You need separate authorization flows for each
• Different scopes — Threads uses threads_basic and threads_content_publish. Instagram uses instagram_basic and instagram_content_publish
• Different endpoints — Threads uses graph.threads.net. Instagram uses graph.facebook.com (confusingly, not graph.instagram.com)
• Content types — Threads supports text-only posts. Instagram requires at least one image or video
• Character limits — Threads allows 500 characters. Instagram captions can be up to 2,200 characters
• Scheduling — Instagram has limited scheduling support via the Content Publishing API. Threads has none natively

If you are already integrated with Instagram, adding Threads is not a trivial copy-paste. The authorization flow, endpoints, and token management are all separate. This is another reason why a unified API like PostEverywhere's saves time — connect your Meta accounts once and post to both Threads and Instagram from the same endpoint.

For a broader overview of how these APIs fit together, see the social media scheduling API guide.

Managing Threads at Scale

If you are scheduling Threads posts for multiple accounts — whether for an agency or a SaaS product — there are a few operational considerations:

Rate limit budgeting. The 250-post per 24-hour limit is per user, not per app. If you have 10 client accounts, each gets its own 250-post budget. But you need to track usage per account to avoid hitting the ceiling.

Token refresh automation. Long-lived tokens expire every 60 days. For 50 accounts, that is a token expiring almost every day. Automate the refresh flow or use PostEverywhere's API which handles this entirely.

Content format optimization. Threads performs best with short, conversational text. The algorithm rewards posts that generate replies. If you are using a Threads scheduling tool, make sure it supports content that plays to the platform's strengths rather than just cross-posting Instagram captions verbatim.

Monitoring and error handling. The Threads API returns standard HTTP error codes, but the error messages can be vague. Build logging around your publishing flow so you can debug failed posts quickly. PostEverywhere's webhook callbacks include detailed error information when a post fails.

FAQs

Can I schedule Threads posts via the API?

Not with the native Threads API — it only supports immediate publishing. You would need to build your own scheduling queue and cron job to trigger posts at specific times. PostEverywhere's API supports native scheduling with a scheduled_at timestamp parameter.

Do I need an Instagram account to use the Threads API?

Yes. Threads authentication routes through Instagram. Your users need an Instagram Business or Creator account that is linked to their Threads profile. This is a Meta platform requirement and applies whether you use the native API or a third-party service.

What content types does the Threads API support?

The Threads API supports text posts (up to 500 characters), single image posts, single video posts, and carousel posts with up to 20 items. You can include URLs in text posts which Threads will auto-preview. GIFs and Stories are not supported via the API.

How do Threads API rate limits work?

The Threads API allows up to 250 publishing actions per user per 24-hour rolling window. Read operations (fetching profiles, insights) have separate limits shared with the Meta Graph API pool. If you are managing multiple accounts, each account has its own publishing quota.

Can I create threaded replies (multi-post threads) via the API?

The content publishing API supports a reply_to_id parameter for replying to existing posts, including your own. This lets you create threaded conversations programmatically. However, there is no batch endpoint to create an entire multi-post thread in a single request — you need to publish each reply sequentially, waiting for the previous post ID before creating the next.

Is the Threads API free to use?

Yes, the Threads API itself is free. There are no paid tiers like the X API. However, you do need to pass Meta's app review process to use publishing permissions in production, which can take several weeks and requires demonstrating a legitimate use case.

Wrapping Up

The Threads API is functional but limited. It handles basic publishing well — text, images, videos, carousels — but lacks scheduling, has a multi-step publishing flow, and requires managing Meta's OAuth lifecycle and token refresh process.

For production use cases, especially those involving scheduling, multiple accounts, or cross-platform publishing, a unified API removes the complexity. PostEverywhere's API handles Threads alongside seven other platforms, with built-in scheduling, media management, and AI content generation.

If you are evaluating your options, start with the developer documentation — it covers authentication, endpoints, and all supported platforms. The API is free to test with no credit card required.

For more platform-specific API guides, see the social media scheduling API hub.