Threads Public Data API | SandBase

Read public Threads profiles, posts, replies, and search with one REST API. No Threads login, no SDK — one SandBase key, built for agent workflows.

Dark cinematic render of Threads profile, post, and reply data flowing through one API conduit into an agent core

Threads is Meta’s text conversation network, and its public profiles, posts, and replies map directly onto brand monitoring, creator research, and social listening. Getting at it programmatically usually means reverse-engineering the app, managing tokens, and rebuilding a scraper every time the app changes.

The SandBase Threads public data API removes that setup tax. It reads public Threads profiles, posts, replies, and search through plain REST endpoints — one SandBase API key, no Threads login and no SDK. The endpoint API reference is the source of truth for each parameter and for the response envelope; the business-payload field names shown below are an illustrative shape, not a guaranteed schema, so confirm them against a live response for the endpoint you call.

This is not Meta’s official Threads API. Use Meta’s official APIs when you need authenticated member actions, posting, or a licensed data agreement. Use SandBase when your workflow needs public, read-only data for research and monitoring. Ready to try it? Get a SandBase API key and browse the Threads endpoints.

Key takeaway

  • One API reads public Threads profiles, posts, replies, reposts, and search.
  • The Model API endpoints documented here are called with POST /v1/api/threads/<path> — pass only that endpoint’s params, no SDK, one SANDBASE_API_KEY.
  • Endpoints key off natural identifiers: a username resolves a profile, then its user_id (the pk/id from user-info) drives post and reply reads, and a post_id drives a single-post read.
  • It returns public, read-only data only. There is no posting, no platform login on your side, and no private data; authenticate with a SandBase API key.

The 2026-11-08 refresh checked threads/web/user-info and threads/web/search-profiles through free inspect and current public reference samples. No paid business request was executed. The wider capability map below is retained for orientation; posts, replies and their identifiers/pagination were not revalidated this round.

Known username: read one user object. Search query: review candidate nodes at xdt_api__v1__users__search_connection.edges[].node. Neither inspected request schema declares page, cursor, end_cursor or limit. The creator research tutorial provides a complete single-request Python helper and setup paths for an existing key, a connected agent or a new project. It does not select the first match or turn missing follower counts into zero.

Which Threads API do you need?

Your needChooseWhy
Post, act as a member, or use account-authorized dataMeta’s official Threads APIMember and account operations run through Meta directly.
Read public profiles, posts, replies, or searchSandBase Threads public-data APIPlain REST, one SandBase key, structured JSON for read-only workflows.
Private or account-only dataNeither public workflowThat data is out of scope for this public-data guide.

What you can get from the Threads API

The catalog is organized on a web surface. Grouped by job:

  • Profiles — public profile info by username (or by id), including bio, follower count, and verified status.
  • Posts & replies — a user’s posts, replies, and reposts, plus a single post’s detail.
  • Search — profile search, plus top and recent post search by keyword.

Availability differs by endpoint, and some upstream reads can be intermittent — treat each endpoint’s live API reference as the source of truth and confirm availability before you build on a specific one.

SandBase Threads API page: description, capability tags, and the endpoint list Historical screenshot, 2026-09-27. The Threads API page on SandBase — a tagged overview and the endpoint list, each with its path.

What Threads provides vs. what SandBase adds

Public data comes from Threads. SandBase does not own or operate Threads; it provides a shared authentication entry point for eligible public-data workflows. Each additional step still needs its own parameter, business-structure, availability and budget checks. The current tutorial checks the profile and candidate-search contracts for independent first requests; it does not verify a profile-to-posts-to-detail chain.

Quick start: one known profile

Use the Model API POST route with a locally configured SANDBASE_API_KEY, not the catalog GET surface. The current profile request has one required input: username.

Shell
curl --fail-with-body --connect-timeout 10 --max-time 90 \
  -X POST https://api.sandbase.ai/v1/api/threads/web/user-info \
  -H "Authorization: Bearer $SANDBASE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "nasa"}'

This command prints the response; it does not validate business completion. Before using it, require status: "completed", an object at outputs[0].data, and a nonempty user object. Missing/null/empty profiles should be reported as errors rather than skipped or turned into zero followers. The linked tutorial implements those checks, timeout/JSON handling and no automatic retry. It preserves optional fields unchanged and adds no provider code0 or success-flag rule absent from these references.

Free inspection on 2026-11-08 lists profile at $0.002 and profile search at $0.003, with eligibility for the organization’s 100 daily shared eligible-API calls, resetting 00:00 UTC. Remaining quota was not queried; eligibility does not guarantee the next call is free.

Historical profile capture, 2026-09-27

The following original response for zuck, run 77059cb9-8616-4be1-abfe-96e82a12b54f, is retained unchanged as historical evidence. It is not today’s follower count or a new execution. The old Python snippets are archived; the current tutorial replaces their silent missing-user fallback.

JSON
{
  "id": "77059cb9-8616-4be1-abfe-96e82a12b54f",
  "status": "completed",
  "model": "threads/web/user-info",
  "outputs": [
    {
      "data": {
        "user": {
          "full_name": "Mark Zuckerberg",
          "biography": "Mostly superintelligence and MMA takes",
          "follower_count": 5744972,
          "is_verified": true,
          "bio_links": [],
          "id": "63055343223",
          "pk": "63055343223"
        }
      }
    }
  ]
}

A successful historical profile capture does not validate a different endpoint. Current search uses a connection/edges/node structure, not the profile user path. Check both the run status and the selected endpoint’s business structure.

SandBase API reference for a Threads endpoint, showing the vendor-qualified URL and the response schema Historical screenshot, 2026-09-27. The endpoint API reference is the source of truth for each parameter name and response path.

Capability map

This navigation map is retained from the earlier article (published 2026-09-27, previously updated 2026-10-01). Posts, replies and post-detail inputs below are historical guidance, not parameters revalidated in the 2026-11-08 profile/search repair.

Capability clusterRepresentative endpointTypical use
Profilethreads/web/user-infoPublic profile signals by username
Poststhreads/web/user-postsRead a user’s posts by user_id (optional end_cursor)
Repliesthreads/web/user-repliesRead a user’s replies by user_id (optional end_cursor)
Post detailthreads/web/post-detailRead a single post by numeric post_id
Searchthreads/web/search-profilesCreator and topic discovery by query

Paging differs by endpoint — several endpoints accept a per-endpoint cursor request parameter. Read each endpoint’s schema, and confirm the endpoint is available before you build on it.

Historical Threads User Posts API parameter reference Historical user-posts parameter reference, 2026-09-27. This is a separate endpoint, not an endpoint-list screenshot; its current behavior was not revalidated in this refresh.

Review before extending the task

An already confirmed handle and a search phrase are different inputs. Search returns candidates, not an authoritative account selection; compare username and intended identity before requesting anything else. This refresh stops after one selected request. A profile-to-posts chain needs its own endpoint inspection and budget. Shared authentication does not make business payloads or availability identical.

Common use cases

Threads profile API for creator research

Call threads/web/user-info with a username to read bio, follower count, verified status, and bio links. Input: a username. Output: a profile record under user. Endpoint: user-info.

Threads posts API for content monitoring

First resolve the profile with threads/web/user-info (a username) to get its pk/id, then read threads/web/user-posts for the user’s recent posts. Input: a user_id (the pk/id from user-info), plus an optional end_cursor for paging. Output: a list of posts. Endpoint: user-posts. Confirm availability against the reference before building on it — this upstream read can be intermittent.

Threads search API for discovery

Run threads/web/search-profiles with a keyword to surface creators around a niche. Input: a keyword. Output: matching profiles. Endpoint: search-profiles.

Keep observations and unknowns separate

A structured profile is useful only if missing information remains visible. An absent follower count is not zero, and an absent verification flag is not false. Even a supplied follower count is not a direct measure of post reach or audience quality. Preserve the retrieval date and unknown fields before creating any comparison table.

The current search sample contains identity fields inside each node; it does not establish a follower-count metric for every candidate. Do not send search results into a ranking function that assumes those metrics exist, or automatically fetch every candidate to fill the gaps. Decide which account to inspect as a separate task.

Limitations and boundaries

  • Public, read-only data only. No posting, following, or private/account-only data.
  • Rate and volume. The first-request example stops on errors. Inspect authentication, billing or rate-limit context before deciding on a separate attempt; no automatic retry or bulk loop is included.
  • Parameters and shapes follow the upstream surface. Identifiers vary: user-info takes a username, user-posts/user-replies take a user_id (the pk/id from user-info), post-detail takes a numeric post_id, and search-profiles takes a query; some historical post/reply routes used end_cursor. The two currently inspected profile/search schemas declare no pagination fields. The profile payload nests under user, while search uses connection/edges/node. Inspect a real response and read the schema first.
  • Verify endpoints against the live reference. Availability and fields can change, and some post/search reads can be intermittent; confirm before building on a specific endpoint.
  • This is not an official Meta partnership. SandBase provides uniform access to public data; respect Threads’ terms and applicable rules for your use case.

FAQ

Do I need a Threads or Meta login? No. You authenticate to SandBase with your SANDBASE_API_KEY. These read endpoints do not require a Threads account or OAuth on your side.

What identifies a profile or a post? A username identifies a profile for user-info, which returns the profile’s pk/id. Use that value as the user_id for user-posts and user-replies. A numeric post_id identifies a single post for post-detail, and search-profiles takes a query.

Why does the profile nest under user? The user-info payload wraps the profile in a user object, with fields such as full_name, biography, follower_count, and is_verified. Read data["user"] defensively and confirm the fields against a live response.

Can I read private or account-only data? No. The API returns public data only. Private and account-authorized content are out of scope.

Start with a profile read

Reuse your existing connection and choose one known-profile lookup or candidate search. The creator research tutorial supplies the checked implementation. When you are ready:

Found this useful? Share it