Threads API Pricing 2026: Free, but Rate-Limited

Threads API pricing in 2026 is free. Meta publishes no paid tier, no per-call fee, and no pricing page in the official Threads developer docs.

I’ve been shipping on social media APIs for years, and Threads is the outlier where the price question actually stops at the docs. X is pay-per-use with no subscriptions. Instagram and Facebook also publish no paid API tier, but they sit behind weeks of Meta App Review. Threads is in the same no-published-fee category, with most of that friction trimmed away.

This guide covers what the Threads API costs in 2026, the 4,800 × impressions rate-limit formula, the 24-hour publishing caps that surprise most builders, the 60-day token refresh most teams forget, and when a wrapper makes more sense than wiring Meta’s auth flow yourself.

Threads API Pricing at a Glance (2026)

Access path	Cost	Best for	Key friction
Threads API (Meta, official)	No paid tier or per-call fee published	Posting, replying, reading insights on your own account	Meta App Review for non-tester users, 60-day long-lived tokens, 500-char text cap
Threads Tester access	No paid tier or per-call fee published	Prototyping before app review	Each tester must accept an invite, app stays in development mode
RapidAPI Meta Threads wrapper	Vendor-listed plans starting at $0/month (verify on the vendor page before subscribing)	Read-only scraping at low volume	Unofficial, no SLA, scraping ToS risk
EnsembleData Threads endpoints	Vendor-listed plans from a $0 free tier (50 units/day) up to about $1,400/month, with a custom Diamond tier above	Bulk public-data extraction	Read-only, no posting capability
Data365 Threads scraper	Basic €300/mo, Standard €850/mo, Custom tier, 14-day no-card free trial, not affiliated with Meta	Public-data scraping at one or more platforms	Vendor explicitly disclaims Meta partnership
Blotato unified API	Starter $29/mo, Creator $97/mo, Agency $499/mo	Posting Threads + 8 other platforms from one endpoint	API access on paid plans only, generating a key ends the free trial

The honest answer is that Meta has not published a paid tier or per-call fee for the Threads API, which is what most readers mean by “free.” The catch is that production access is still gated by Meta App Review and capped by a rate-limit formula tied to your account’s impression volume, which we walk through below.

For teams that just need to publish to Threads (and eight other platforms) without writing the OAuth flow themselves, Blotato wires the whole posting layer up behind one endpoint and removes the app-review step from the critical path. The dashboard has a 7-day free trial. The Blotato API runs on paid plans starting at $29/month.

Dashboard trial: 7 days, no credit card · API access: paid plans only

What Changed in 2026

Three things shifted on the Threads developer surface in the past twelve months.

The first is that Threads now has a proper public API. Meta opened the public version to all developers on June 18, 2024 with read and publish endpoints. Through 2025 it expanded to include insights, reply management, deletion, and the threads_location_tagging permission. By 2026 the surface area is wide enough to build a real client on top of, not just a posting bot.

The second is that the 24-hour publishing caps were formalized in the docs and a dynamic endpoint was shipped alongside them. The current default ceiling per profile is 250 posts, 1,000 replies, 100 deletions, and 500 location searches inside any rolling 24-hour window. You can also pull your real-time usage with GET /{threads-user-id}/threads_publishing_limit, which returns quota_usage, reply_quota_usage, delete_quota_usage, and location_search_quota_usage. The dynamic check is the safer pattern in 2026, since Meta has been iterating on these numbers.

The third is a token-lifecycle nuance worth wiring into your auth flow. Per Meta’s long-lived tokens guide, short-lived access tokens last 1 hour, long-lived tokens last 60 days, and long-lived tokens can be refreshed any time after they are at least 24 hours old and not yet expired (the refresh call requires the threads_basic permission). On top of that, permissions granted by users with private Threads profiles expire after 90 days, per Meta’s own wording. If your app onboards users with private profiles, plan a re-permission flow.

Threads API Pricing, in Plain English

Each access path, in dev-to-dev terms.

Official Threads API (no published paid tier)

The official Threads API surface lives entirely inside the Meta for Developers portal and has no published paid tier. You create a Meta app, add the Threads use case, request the permissions you need, and go through Meta App Review to take your app out of development mode.

The core scopes on Meta’s overview and get-started pages are threads_basic, threads_content_publish, threads_read_replies, threads_manage_replies, threads_manage_insights, threads_delete, and threads_location_tagging. Three more live on dedicated sub-pages: threads_keyword_search, threads_manage_mentions, and threads_profile_discovery. A newer threads_share_to_instagram scope was added on March 25, 2026, authorizing the crossreshare_to_ig and crossreshare_to_ig_dark_mode parameters on the publishing endpoint. Pull from whichever sub-page matches your use case.

Once your app is approved, it can act on any user who completes the OAuth flow, subject to the rate-limit formula below and the 24-hour caps. Meta’s public Threads API docs do not list a monthly subscription, a per-call charge, or a paid quota-increase product anywhere on the developer surface.

Per Meta’s Threads posts media spec: 500-char text limit, JPEG/PNG up to 8 MB (10:1 aspect, 320-1440 px width), MOV/MP4 up to 1 GB and 300 seconds, carousels 2-20 items. Text posts cap total links (inline + link_attachment) at 5. Posts over the cap fail with THREADS_API__LINK_LIMIT_EXCEEDED, enforced since December 22, 2025.

Threads Tester access (no review needed)

Before app review, your app stays in development mode. You invite Threads Testers, and each gets the permissions you’ve configured immediately after accepting the invite (Meta caps the tester count per app at the platform-wide limit, so check the current ceiling on your app’s roles page). This is the path indie developers use to ship for themselves: invite yourself as a tester, build the integration, skip app review as long as the only users are accepted testers.

The catch is the app stays private. You cannot onboard arbitrary users until the app is approved through review.

Third-party wrappers (RapidAPI, EnsembleData, Data365)

These vendors sell Threads data by scraping public pages, not through Meta’s official API. Three to know: RapidAPI’s Meta Threads endpoint (tiers from $0/100 requests up to $200/1M, verify live prices), EnsembleData (free 50/day tier up to ~$1,400/mo Platinum, with custom Diamond above), and Data365 (Basic €300/mo, Standard €850/mo, Custom, 14-day no-card trial). All three are read-only scrapers, not posting APIs. They fit researchers and brand monitors who accept the trade-offs: no SLA, unofficial endpoint stability, and Meta’s terms prohibit automated collection “without prior permission” (the law on public-data scraping is split since Meta v. Bright Data, 2024).

The Real Cost: Meta App Review and Token Refresh

Meta does not publish a paid tier or per-call fee for the Threads API, but production access is not free of calendar time or maintenance. The cost shows up in two places.

App review. To use the Threads API for any non-Tester user, you submit each permission for Meta App Review with a screencast, privacy policy, terms-of-service URL, and (for many permissions) business verification. First-round rejections are common. Meta’s App Review introduction says processing “typically takes less than one week, often only 2 to 3 days,” with longer windows during high volume.

Token refresh. Short-lived tokens last 1 hour. Long-lived tokens last 60 days and refresh between 24 hours and 60 days from issue (the token must still carry threads_basic). Permissions from users on private profiles expire after 90 days. Build a refresh job before the 60-day mark plus a re-permission flow for private-profile users.

Neither is a dollar cost. Both are calendar costs. They are the reason indie builders who only need to post to their own account often skip app review and stay in development mode with accepted testers.

The 4,800 Multiplier: Threads’ Real Rate Limit

The Threads API limits how often you can call it using a formula tied to impressions. The number to remember is 4,800.

Per Meta’s overview docs, the call cap is counted per app and app-user pair, based on the impressions that user’s Threads account received in the last 24 hours. The 24-hour API call ceiling is:

Calls in 24 hours = 4,800 × Number of impressions

The minimum impression count Meta uses in this calculation is 10, so the floor is 48,000 calls per 24-hour window even on a brand-new account with no reach. From there it scales with whatever the account actually got served.

Meta also enforces two CPU-based ceilings on top of this: 720,000 × impressions for total_cputime and 2,880,000 × impressions for total_time. Most builders never hit those.

What actually trips people up is not the call ceiling. It’s the 24-hour publishing caps, which sit on top of the call formula:

Action	24-hour limit per profile
Posts (carousels count as one)	250
Replies	1,000
Deletions	100
Location searches	500

If you’re posting on your own account, 250 posts a day is generous. If you’re running a tool that posts on behalf of multiple users, 250 is per profile, which is fine. If you’re running an analytics product that does heavy delete-and-republish flows, 100 deletions is the cap you’ll hit first.

Meta also exposes these quotas dynamically. GET /{threads-user-id}/threads_publishing_limit returns the current usage fields (quota_usage, reply_quota_usage, delete_quota_usage, location_search_quota_usage) alongside matching config objects (config, reply_config, delete_config, location_search_config). Inspect the returned config objects at runtime rather than hard-coding numbers, because Meta can change values or windows without notice.

Patterns That Trip Up Most Developers

Four things bite people the first time they ship on the Threads API. If I had to rank them by how often I’ve seen builders trip, #3 and #4 sit at the top.

1. Forgetting that media has to be on a public URL. Threads doesn’t accept a multipart upload. You host the image or video on your own public server (or S3, or a CDN), then pass the URL to the create-container endpoint. If Meta can’t fetch the URL, the create call still returns a container ID but the async status flips to FAILED_DOWNLOADING_VIDEO. You only see the failure if you poll the container status endpoint, which Meta recommends doing once a minute for up to 5 minutes.
2. Skipping the container publish pattern. Threads uses a two-step publish flow: POST a media container, then POST to publish it. Text-only posts have an opt-in shortcut in the publishing reference. Pass auto_publish_text on the create-container call and Meta publishes the post in one step.
3. Missing the 60-day token refresh. Long-lived tokens last 60 days. If you don’t refresh them between 24 hours and 60 days after issue, the user drops off the API. Add a refresh job, and a separate re-permission flow for users on private profiles (their permissions expire after 90 days).
4. Underestimating App Review. Most teams plan for one submission. Plan for two or three. Meta doesn’t publish a target rejection-cycle SLA for Threads, but in practice each rejection adds about a week of calendar time before you can resubmit.

Real-World Access Examples

Three personas show what the Threads API actually costs in calendar time and dollars.

The Indie SaaS Publisher

You’re a solo founder posting 5 to 10 times a day to your own Threads account, running everything as a Tester on your own Meta app.

• Threads API monthly cost: no published API fee in Meta docs
• App review: skipped (you stay in development mode forever as your own Tester)
• Token refresh: automated job before the 60-day mark, ~30 minutes to wire
• Total: no published API fee, ~2 hours of setup

The Agency Posting for 30 Clients

You’re running a content agency that posts on behalf of 30 different Threads accounts.

• Threads API monthly cost: no published API fee in Meta docs
• App review: 2 to 6 weeks for threads_basic + threads_content_publish + threads_manage_replies, plus 1 to 2 weeks for business verification
• 60-day token refresh across 30 accounts plus private-profile re-permission: ongoing engineering
• Total: no published API fee, 4 to 8 weeks to launch, recurring auth maintenance

The Brand Monitor or Researcher

You’re tracking public Threads conversation for clients. Reading at scale, not posting.

• Official Threads API: more limited than scraper products for public-data research, depends on which scopes (keyword search, profile discovery, mentions) clear app review
• EnsembleData: roughly $200 to $1,400/month by volume
• RapidAPI Meta Threads: tiers from $0/month, vendor-listed
• Data365: Basic €300/mo, Standard €850/mo, Custom, 14-day no-card trial
• Total: ~€300 to ~$1,400/month at published vendor ranges

Already Using Instagram Graph API? Threads Is Easier

If you’re coming from Instagram Graph API (the full breakdown is in Instagram API Pricing), the Threads API is a step down in friction. The docs don’t list an Instagram Business Account or a linked Facebook Page as a prerequisite, the permission scopes are tighter (threads_basic plus whatever specific action you need, not a stack of instagram_* plus the Facebook bridge), and the rate-limit formula is the same 4,800 × impressions math that Instagram’s Business Use Case (BUC) limit uses. The mental model carries over.

The Honest Pitch: Skip the Approval Cycle and Use Blotato

I’d be a bad founder if I didn’t say the comparison below isn’t neutral. I built Blotato, and the pitch is biased on purpose.

If you only need to post to Threads (and not read at research-volume), going direct to Meta’s API is fine. Meta does not publish a paid tier or per-call fee for it. The question is whether your time is free too.

You still write the OAuth flow, host the public media URL server, submit for app review, and build the 60-day token refresh plus private-profile re-permission paths. And you do it again for every other social media API your product needs on top of Threads.

One API. Every social platform.

Blotato’s unified API turns the multi-platform posting job into a single HTTP request:

curl -X POST https://backend.blotato.com/v2/posts \
  -H "blotato-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "post": {
      "accountId": "YOUR_THREADS_ACCOUNT_ID",
      "target": { "targetType": "threads" },
      "content": {
        "text": "Posted to Threads via the Blotato API.",
        "mediaUrls": [],
        "platform": "threads"
      }
    }
  }'

That’s the minimal Threads payload. For Threads-specific behavior, the Blotato API also supports target.replyControl ("everyone", "accounts_you_follow", or "mentioned_only") and content.additionalPosts[] for multi-post thread chains, both documented in the Blotato Threads platform guide.

The same envelope works for the other 8 platforms in the API enum, but each platform’s target fields differ (Facebook needs pageId, Pinterest needs boardId, YouTube and TikTok need privacy flags, etc.). See the publish-post API reference for the full schema, or the Blotato API quickstart for a minimal walkthrough.

The API is included on every paid plan, with no per-post charges layered on top. The pricing page words it directly: “No per-post fees, no seat fees, no hidden tax on your soul.”

Blotato plans:

• Starter ($29/month): 1,250 AI credits, 20 connected accounts
• Creator ($97/month)
• Agency ($499/month)

Start a free week of Blotato →

Sabrina’s Take

I’m biased, obviously. I built Blotato because going direct to each social API stops penciling out the moment a product touches more than two networks. Threads is the friendliest API of the bunch right now, and even Threads still costs you the OAuth flow, the media-host server, the app review, and a token refresh job that runs forever.

If you’re posting to one account on one platform forever, build it yourself and run as a Tester. You’ll save the $29. If you’re building a product that touches more than two networks, wrap it. The hours you save on plumbing pay for the subscription in a week.

FAQs

Is the Threads API free in 2026?

Meta does not publish a paid tier or a per-call fee for the Threads API in the official developer docs, which is what most people mean by “free.” The cost is in calendar time: Meta App Review for production access, and a 60-day long-lived token that has to be refreshed (plus a 90-day expiration for permissions granted by users on private profiles).

How do I get access to the Threads API?

Create a Meta app, add the Threads use case, request the permissions you need (start with threads_basic and threads_content_publish), and either invite yourself as a Threads Tester for development or submit each permission to Meta App Review for production users. The full setup is in Meta’s Threads API get-started guide.

What are the Threads API rate limits?

The base formula is 4,800 × impressions in any 24-hour window, with a minimum impression count of 10 (so a floor of 48,000 calls per day). On top of that, you can publish a maximum of 250 posts, 1,000 replies, 100 deletions, and 500 location searches per profile per 24 hours.

Do I need an Instagram Business Account to use the Threads API?

Meta’s Threads setup docs do not list an Instagram Business Account or a linked Facebook Page as a prerequisite. The OAuth flow runs through the Threads authorization window directly, separate from Facebook Login for Business.