🧵 Threads Search Post Scraper: Posts, Quotes & Replies

Threads Post Scraper — Search Results, Quotes and Reply Threads

Threads Post Scraper turns a Threads post URL, a numeric post ID, or a search phrase into clean, structured JSON — full post text, likes, replies, quote/repost links, mentions, hashtags, and (with a session cookie) the complete paginated reply thread. Every row is typed and flattened, so there's no HTML to parse and no nested guesswork. Add your targets below and start a run to see it in action.

🧵 What is Threads Post Scraper: Posts, Quotes & Replies?

Threads Post Scraper: Posts, Quotes & Replies is an Apify Actor that fetches public Threads posts by URL or post ID, runs a real multi-result keyword/hashtag search, and pulls the reply conversation under each post — including quote posts and reposts resolved to a clean URL. It returns typed, structured JSON with no scraping or parsing code required. No Threads account is needed for basic use; a logged-in sessionid cookie is only required to unlock full paginated replies and deeper search pagination. It's built for social listening teams, market researchers, growth/marketing analysts, and developers feeding Threads conversations into AI agents or RAG pipelines.

🔓 What Threads post data is publicly available to scrape?

Threads serves post pages and search results over the open web without requiring a login — this Actor reads exactly that public surface. Some depth (full reply pagination, nested sub-replies, search results past the first page) sits behind a logged-in session, which is why those are the only inputs gated on a sessionid cookie.

Data category	Publicly available (no login)	Requires a logged-in sessionid
Post text, media and captions	✅
Engagement counts (likes, replies, reposts, quotes, reshares)	✅
First page of search results (~20 posts per query)	✅
Replies already embedded on a post's own page	✅
Full paginated reply thread beyond what's embedded		✅
Nested sub-replies (replies to other commenters)		✅
Search result pages beyond the first (~20)		✅
View count on search-derived posts		❌ not exposed by Threads on this surface

Threads Post Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall is accessed without a cookie you provide yourself.

📦 What data can I extract with Threads Post Scraper: Posts, Quotes & Replies?

Every saved row — post or reply — carries the post's identity and media fields, its engagement metrics, and a set of conversation/entity fields the Actor computes on top of Threads' own payload.

Post & author identity

Field name	Description
post_url	Canonical https://www.threads.com/@user/post/CODE link, built from username + code
pk	The post's numeric Threads/Instagram media ID
code	The post's shortcode (the part of the URL after /post/)
id	Threads' own composite post ID
user	Nested author object: username, full_name, is_verified, profile_pic_url, friendship_status, and related fields, mirroring Threads' schema
caption	{ "text": "..." } — the post's text content
caption_add_on / caption_is_edited	Caption edit metadata, as returned by Threads
media_type	Threads' internal numeric media-type code (text, image, video, carousel)
image_versions2 / video_versions / carousel_media	Media asset URLs, present only for the relevant media type
original_height / original_width	Dimensions of the primary media asset, when present
accessibility_caption	Alt-text for image media, when Threads returns one
usertags	Tagged users in the media, when present
audio / has_audio / transcription_data	Audio attachment fields, when the post carries one
canonical_url	Threads' own canonical link for the post
is_paid_partnership	Whether Threads flags the post as paid partnership content
giphy_media_info	GIF attachment metadata, when present
metaPlace / meta_place	Location tag, when the poster added one (usually null)
gen_ai_detection_method	Threads' AI-generated-content label, defaults to {"detection_method": "NONE"}
logging_info_token / organic_tracking_token / __token	Opaque internal Threads tracking tokens, passed through unchanged
like_and_view_counts_disabled	Whether the author hid engagement counts
media_overlay_info / sharing_friction_info	Threads-internal overlay/sharing-friction objects, mostly null/default
text_post_app_info	Full nested Threads-app metadata object (share_info, text_fragments, reply settings, and the rest of Threads' own schema) — kept intact for advanced use

Engagement metrics

Field name	Description
like_count	Total likes on the post/reply
direct_reply_count	Reply count, flattened from text_post_app_info to the top level
repost_count	Repost count, flattened to the top level
quote_count	Quote-post count, flattened to the top level
reshare_count	Reshare count, flattened to the top level
view_count	Impression count — only populated for a post fetched on its own page, or a post whose reply thread was fetched with a sessionid; null for search-derived rows
taken_at	Unix timestamp the post was published
has_liked	Whether the (anonymous) viewer has liked it — always false without a session

Conversation labeling, quotes & entities

Field name	Description
type	"post" for a top-level target, "reply" for a reply row
isChild	true for reply rows, false for posts
parentId	The parent post's pk on reply rows; null on post rows
reply_url	Reply-only: the reply's own post URL
source_post_url	Reply-only: the URL of the post the reply belongs to
reply_to_username	Reply-only: the username the reply is directed at
mentions	Array of { "username": "..." } objects parsed from the post text
hashtags	Array of hashtag strings (without #), parsed from text fragments or the caption
urls	Array of Threads links found in the post text, normalized to https://www.threads.com/t/CODE/
is_quote_post / quoted_post_url	Whether the row quotes another post, and that post's resolved URL
is_repost / reposted_post_url	Whether the row is a repost, and the original post's resolved URL
scrapedAt	ISO-8601 UTC timestamp of when this Actor collected the row

🤖 Add-on: Need additional Threads data?

Pair this Actor with other Scraper Engine tools when a Threads workflow spans platforms — for example, cross-referencing a Threads author against their Twitter (X.com) Tweets & Profiles Scraper activity, or feeding the same conversation-analysis pipeline with TikTok Data Scraper comment data. See Related scrapers below for the full list.

⚔️ How does Threads Post Scraper differ from the official Threads API?

Meta's Threads API includes a /keyword_search endpoint for public post search, but it requires a registered Meta developer app and Meta's app-review approval before that endpoint is enabled for your app — this Actor runs immediately with no Meta account at all (checked on Meta for Developers' Keyword Search documentation, 2026-08-04).

Feature	Threads API (official)	Threads Post Scraper: Posts, Quotes & Replies
Access	Requires a Meta developer app plus Meta's app-review approval before /keyword_search is usable	Runs on Apify with a URL, post ID, or search phrase — no Meta app, no review
Search input	Keyword/topic-tag search via /keyword_search	Same post URL, post ID, and search-phrase inputs accepted together in one list
Full reply threads	Endpoints are scoped around your own linked account's posts and replies	Fetches the full paginated reply thread, including nested sub-replies, for any public post (gated on a sessionid)
Output shape	Raw Graph API JSON per Meta's schema	Normalized JSON row per post/reply, with engagement counts flattened and quote/repost links pre-resolved
Setup time	App creation and review process before the first call	Add a target and click Start
Rate limits	Governed by Meta's platform limits and app-review tier	Bound by this Actor's own maxItems / maxRepliesPerPost caps and your Apify run settings

Use the official Threads API when you're building inside Meta's own review process and only need data tied to your linked app. Use Threads Post Scraper when you want ad-hoc, no-signup extraction of arbitrary public posts, searches, and reply threads today.

🚀 How to use Threads Post Scraper: Posts, Quotes & Replies

Threads Post Scraper runs on the Apify platform — no separate signup, and no credentials required unless you want the deeper reply/search coverage a sessionid unlocks.

1. Open the Actor on its Apify Store page and click Try for free (or Run, if you already have it saved).
2. Fill in the required urls field with at least one post URL, post ID, or search phrase.
3. Optionally set maxItems, includeReplies, includeNestedReplies, maxRepliesPerPost, and/or a sessionid cookie for deeper coverage.
4. Click Start and watch rows stream into the dataset in real time.
5. Download results as JSON, CSV, Excel, or any other format Apify's dataset export supports, or pull them via the API.

How to scale to bulk post extraction

urls is an array — add one target per line and every post URL, post ID, and search phrase in the list is processed in the same run, each independently classified by its shape. There's no separate "bulk mode" toggle needed: a list of 50 targets and a list of 1 both run through the same loop, and maxItems applies as a single cap across the whole run, not per target.

💡 What can you do with Threads post data?

• 📊 Social listening analysts track a brand or topic by feeding search phrases into urls and monitoring like_count, repost_count, and quote_count trends over repeated runs.
• 🧵 Conversation researchers studying how a thread evolves use type, isChild, and parentId to reconstruct the full post-and-reply tree without manually matching IDs.
• 📣 PR and community teams use mentions and reply_to_username to find who is being tagged in a conversation and route replies to the right person.
• 🔁 Trend analysts use is_quote_post / quoted_post_url and is_repost / reposted_post_url to trace how a post spreads through quotes and reposts.
• 🤖 AI engineers pass caption.text, hashtags, and mentions straight into a RAG index or an agent's context window — the JSON needs no cleanup before use.

🛡️ How does Threads Post Scraper handle rate limits and blocking?

Post-URL and post-ID fetches rotate through a small pool of desktop user agents and retry on 429/502/503/504 responses and network errors, backing off exponentially (capped at 10 seconds) with random jitter, up to 3 attempts. Search and reply-thread requests go out through curl_cffi with a Chrome browser network fingerprint. On top of that, every request type runs through an automatic proxy ladder: it starts with no proxy, escalates to a datacenter (SHADER) tier if that fails, then to residential proxies if datacenter also fails — and once escalated to residential, it stays there for the rest of that operation, retrying with a fresh session up to 3 times before giving up. If a target still can't be collected after all of that, the Actor logs it and moves on to the next target rather than failing the whole run. Threads Post Scraper does not solve CAPTCHAs.

⬇️ Input

Parameter	Required	Type	Description	Example value
urls	Yes	array	Each line: a full post URL (threads.com/threads.net), a numeric post ID (10+ digits), or a search phrase. A search phrase returns every distinct matching post, not just one.	["https://www.threads.com/@zuck/post/AbCdEfGhIjK", "Mark Zuckerberg"]
maxItems	No	integer (min 0)	Cap on how many top-level posts to save across the whole run. Replies are collected per post separately and do not count against this cap. Leave empty or 0 for no limit.	10
includeReplies	No	boolean (default true)	Capture the conversation under each post: embedded replies are always captured and labeled; with a sessionid, the full paginated reply thread is also fetched.	true
includeNestedReplies	No	boolean (default false)	By default only first-level replies are collected. Enable to also capture nested sub-replies. Only affects the sessionid-powered full reply-thread fetch.	false
maxRepliesPerPost	No	integer (min 0, default 20)	Cap on how many reply rows to collect per post, across embedded + fetched replies combined.	20
sessionid	No	string (secret)	A logged-in Threads/Instagram sessionid cookie, needed for the full paginated reply thread and for search pagination beyond the first page (~20 results). Leave empty to still get posts, one page of search results, and embedded replies.	""
proxyConfiguration	No	object	Apify Proxy settings. Leave off for a simple run; turn on to route requests through Apify's proxy network on busy or sensitive targets.	{ "useApifyProxy": false }

Example input

{
  "urls": [
    "https://www.threads.com/@zuck/post/AbCdEfGhIjK",
    "Mark Zuckerberg"
  ],
  "maxItems": 10,
  "includeReplies": true,
  "includeNestedReplies": false,
  "maxRepliesPerPost": 20,
  "sessionid": "",
  "proxyConfiguration": { "useApifyProxy": false }
}

⬆️ Output

Results are pushed to the Actor's default dataset as typed, normalized JSON — one row per post and one row per reply, with a consistent schema across runs. Export as JSON, CSV, Excel, XML, RSS, or HTML directly from the dataset, or pull it through the Apify API. Two dataset views ship with the Actor: Posts & replies at a glance (the default) and a Conversation view built for reading posts vs. replies side by side.

Example output

{
  "post_url": "https://www.threads.com/@zuck/post/C3fkP2SIVGP",
  "pk": "3283746192837465",
  "user": {
    "friendship_status": { "muting": false, "following": false, "followed_by": false, "outgoing_request": null, "blocking": null },
    "id": "314216",
    "pk": "314216",
    "text_app_last_visited_time": 0,
    "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/sample.jpg",
    "username": "zuck",
    "full_name": "Mark Zuckerberg",
    "transparency_label": null,
    "transparency_product": null,
    "transparency_product_enabled": false,
    "is_verified": true,
    "text_post_app_is_private": false,
    "has_onboarded_to_text_post_app": true
  },
  "text_post_app_info": {
    "is_post_unavailable": false,
    "pinned_post_info": null,
    "id": "3283746192837465_text_post",
    "share_info": {
      "reposted_post": null,
      "is_reposted_by_viewer": false,
      "can_quote_post": true,
      "quoted_attachment_author_attribution_allowed": true,
      "quoted_attachment_post_unavailable": false,
      "quoted_attachment_post": null,
      "quoted_post": null
    },
    "show_header_follow": true,
    "self_thread_info": null,
    "is_spoiler_media": false,
    "is_markup": false,
    "special_effects_enabled_str": "0",
    "reply_control": "everyone",
    "can_reply": true,
    "can_private_reply": false,
    "is_ghost_post": false,
    "tag_header": null,
    "direct_reply_count": 812,
    "repost_count": 240,
    "quote_count": 96,
    "reshare_count": 55,
    "text_fragments": {
      "fragments": [
        { "fragment_type": "plain_text", "link_fragment": null, "mention_fragment": null, "plaintext": "Shipping a new open-source model this week ", "linkified_web_url": null, "linkified_in_app_url": null, "styling_info": null },
        { "fragment_type": "hashtag", "link_fragment": null, "mention_fragment": null, "plaintext": "#AI", "linkified_web_url": null, "linkified_in_app_url": null, "styling_info": null }
      ]
    },
    "is_reply": false,
    "reply_to_author": null,
    "fediverse_info": { "is_federated": false, "enqueued_for_federation": null, "federated_like_count": null },
    "self_thread_count": 0,
    "root_post_author": null,
    "is_liked_by_root_author": false,
    "post_unavailable_reason": null,
    "post_tombstone_info": null
  },
  "id": "3283746192837465_314216",
  "logging_info_token": "AbCdEf1234567890",
  "is_paid_partnership": false,
  "audio": null,
  "caption": { "text": "Shipping a new open-source model this week #AI" },
  "caption_is_edited": false,
  "transcription_data": null,
  "carousel_media": null,
  "code": "C3fkP2SIVGP",
  "image_versions2": null,
  "original_height": null,
  "original_width": null,
  "accessibility_caption": null,
  "usertags": null,
  "video_versions": null,
  "has_audio": false,
  "media_type": 19,
  "caption_add_on": null,
  "has_liked": false,
  "like_count": 15234,
  "taken_at": 1751212800,
  "media_overlay_info": null,
  "sharing_friction_info": { "should_have_sharing_friction": false, "sharing_friction_payload": null },
  "canonical_url": "https://www.threads.com/@zuck/post/C3fkP2SIVGP",
  "giphy_media_info": null,
  "metaPlace": null,
  "meta_place": null,
  "gen_ai_detection_method": { "detection_method": "NONE" },
  "organic_tracking_token": "eyJ2ZXJzaW9uIjo1fQ==",
  "__token": "3283746192837465_314216",
  "like_and_view_counts_disabled": false,
  "direct_reply_count": 812,
  "repost_count": 240,
  "quote_count": 96,
  "reshare_count": 55,
  "mentions": [],
  "hashtags": ["AI"],
  "urls": [],
  "is_quote_post": false,
  "quoted_post_url": null,
  "is_repost": false,
  "reposted_post_url": null,
  "view_count": 482913,
  "type": "post",
  "isChild": false,
  "parentId": null,
  "scrapedAt": "2026-08-04T09:12:33.104Z"
}

A reply row carries the same shape plus three reply-only fields, with type/isChild/parentId flipped:

{
  "type": "reply",
  "isChild": true,
  "parentId": "3283746192837465",
  "reply_url": "https://www.threads.com/@aiwatcher/post/CxYz789Abc",
  "source_post_url": "https://www.threads.com/@zuck/post/C3fkP2SIVGP",
  "reply_to_username": "zuck",
  "like_count": 46,
  "scrapedAt": "2026-08-04T09:12:34.512Z"
}

⚙️ How does it work?

Post-URL and post-ID targets are fetched as server-rendered HTML directly from Threads, with the largest thread block on the page parsed out of its embedded JSON. Search targets and full reply threads go through Threads' own GraphQL endpoints instead, using a browser-fingerprint-impersonating HTTP client. Every request path runs behind the proxy ladder described above, so a blocked request retries on a stronger connection automatically rather than failing outright. Only what a logged-out visitor (or, with your own sessionid, a logged-in one) can already see is ever returned — nothing is inferred or fabricated when data isn't accessible. The parser is schema-tolerant: several known key-name variants are probed for each field, and any unrecognized field Threads adds is preserved rather than dropped, so the output shape stays stable even as Threads' internal payloads shift.

🔌 Integrations

Threads Post Scraper runs on Apify, so it works with everything already built around the Apify platform.

Calling Threads Post Scraper programmatically

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("<username>/threads-search-post-scraper-posts-quotes-and-replies").call(
    run_input={
        "urls": ["Mark Zuckerberg"],
        "maxItems": 10,
        "includeReplies": True,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["post_url"], item["like_count"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request to the Apify API.

No-code tools (n8n, Make)

In n8n, use Apify's node or an HTTP Request node pointed at the run-sync endpoint to start a run and pull the dataset items into your workflow. In Make, use Apify's official app module to run the Actor and pass its output into downstream scenario steps — no custom code required in either case.

⚖️ Is it legal to scrape Threads posts?

Scraping publicly visible Threads posts is generally legal — this Actor only collects what any logged-out visitor to a post page or search results page can already see. Because each row carries the identifiable author of a post or reply (username, full_name, profile_pic_url), this data counts as personal data under regimes like GDPR and CCPA where they apply, so you are responsible for having a lawful basis before storing or reusing it — particularly for EU or California residents' data, and especially at bulk scale. Consult legal counsel if your use case involves bulk storage of personal data.

❓ Frequently asked questions

What Threads post fields does Threads Post Scraper return?

The top real fields are caption.text, like_count, direct_reply_count, view_count, and taken_at, alongside conversation fields like type, is_quote_post, and hashtags. See What data can I extract above for the full field breakdown.

Does Threads Post Scraper require a Threads account or login?

No — for post URLs, post IDs, the first page of search results, and embedded replies. A logged-in sessionid cookie is only required to fetch the full paginated reply thread (including nested sub-replies) and to page search results past the first ~20.

How many Threads posts can I extract in one run?

maxItems caps how many top-level posts are saved per run (leave empty or 0 for no cap), and maxRepliesPerPost caps replies per post independently — replies never count against the post cap. There is no separate hard ceiling enforced by the Actor beyond those two inputs and your Apify run's own resource limits.

What happens if a post is deleted, a search matches nothing, or the page can't be parsed?

That target is skipped and logged, and the run continues with the remaining targets — it does not fail the whole run. A search phrase that returns zero results, or a post page whose HTML no longer matches Threads' known layout, is treated the same way: no rows for that target, an informative log line, and the rest of your urls list still runs.

Can I scrape multiple Threads posts and searches at once?

Yes — urls accepts a list, and each line is independently classified as a post URL, a numeric post ID, or a search phrase, all processed in the same run.

Does Threads Post Scraper work with Claude, ChatGPT, and other AI agent tools?

It's callable as an HTTP endpoint via the Apify API by any agent framework that can make a request — start a run, poll or wait for it, then read the dataset. There is no dedicated MCP server for this Actor at this time.

How does Threads Post Scraper compare to other Threads scrapers?

No independently verified comparison data is available for other Threads scrapers at this time, so no specific claims are made here. What can be said from this Actor's own source and schema: it returns every distinct match for a search phrase rather than a single result, resolves quote/repost links to clean URLs on every row, and degrades honestly (no fabricated replies) when no sessionid is supplied.

Does Threads Post Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors needed. Pass it directly to an LLM prompt, index it into a vector store, or feed it to an agent tool.

What happens when Threads changes its layout or anti-bot system?

The parser is schema-tolerant by design: it probes several known key-name variants for each field and preserves any field it doesn't recognize rather than dropping it, so minor upstream schema changes don't blank the output. No specific update-turnaround time is promised.

Can I use Threads Post Scraper without managing proxies or browser infrastructure?

Yes — the Actor handles user-agent rotation, retry/backoff on failed requests, and an automatic no-proxy → datacenter → residential proxy escalation ladder on your behalf. You don't need to configure any of it unless you want to.

Which Threads post fields work best for AI training data and RAG indexing?

For RAG, index caption.text alongside hashtags and mentions for retrievable context. For training data or structured analysis, like_count, direct_reply_count, repost_count, quote_count, and taken_at are the most consistently populated numeric fields across posts and replies alike — all fields return as typed primitives (strings, numbers, booleans, or null), never as strings that need re-parsing.

🔗 Related scrapers

Scraper	What it extracts
Twitter (X.com) Tweets & Profiles Scraper	Public X posts and profile stats, with search gated on session cookies too
Facebook Group Posts And Details Scraper: Comments & Engagement Analytics	Facebook group posts, threaded comments/replies, and group profile details
LinkedIn Profile Post Scraper	Posts from LinkedIn profile pages, with reactions and comments
Reddit Subreddit Members Scraper	Active Reddit participants sourced from a subreddit's post and comment feeds
TikTok Data Scraper	TikTok videos, profiles, comments/replies, hashtags, and music data

💬 Your feedback

Found a bug, or a Threads field you need that isn't showing up in the output? Let us know through the Issues tab on this Actor's Apify Console page, or leave a review there — every report gets read and helps prioritize the next update.