# 🧵 Threads Search Post Scraper: Posts, Quotes & Replies (`scraper-engine/threads-search-post-scraper`) Actor

Threads Search Post Scraper extracts posts from Threads search results based on keywords, hashtags, or topics. Collect post text, usernames, profile links, timestamps, likes, replies, and other public data in structured output. Great for trend tracking, research, and monitoring conversations.

- **URL**: https://apify.com/scraper-engine/threads-search-post-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 18 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### 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](https://apify.com/store) activity, or feeding the same conversation-analysis pipeline with [TikTok Data Scraper](https://apify.com/store) 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](https://developers.facebook.com/docs/threads/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

```json
{
  "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

```json
{
  "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:

```json
{
  "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

```python
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](https://apify.com/store) | Public X posts and profile stats, with search gated on session cookies too |
| [Facebook Group Posts And Details Scraper: Comments & Engagement Analytics](https://apify.com/store) | Facebook group posts, threaded comments/replies, and group profile details |
| [LinkedIn Profile Post Scraper](https://apify.com/store) | Posts from LinkedIn profile pages, with reactions and comments |
| [Reddit Subreddit Members Scraper](https://apify.com/store) | Active Reddit participants sourced from a subreddit's post and comment feeds |
| [TikTok Data Scraper](https://apify.com/store) | 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.

# Actor input Schema

## `urls` (type: `array`):

Each line: a full post URL (threads.com or threads.net), a numeric post ID (10+ digits), or a search phrase. A search phrase now returns every distinct matching post (not just one). Example URL: https://www.threads.com/@zuck/post/AbCdEfGhIjK - example phrase: Mark Zuckerberg

## `maxItems` (type: `integer`):

Cap on how many top-level posts to save across the whole run. Replies are collected per post separately (see below) and do not count against this cap. Leave empty (or 0) for no limit.

## `includeReplies` (type: `boolean`):

Capture the conversation under each post: replies embedded on the post's own page are always labeled correctly; with a sessionid below, a full paginated reply thread is also fetched. Rows are tagged type="post"/"reply", isChild, and parentId so posts and replies are never mixed up in the Output table.

## `includeNestedReplies` (type: `boolean`):

By default only first-level replies (directly replying to the original post) are collected. Enable this to also capture nested sub-replies (replies to other commenters in the same conversation). Only affects the sessionid-powered full reply-thread fetch.

## `maxRepliesPerPost` (type: `integer`):

Cap on how many reply rows to collect per post (across embedded + fetched replies combined). Default 20.

## `sessionid` (type: `string`):

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 per query, and whatever replies are already embedded on a post's own page.

## `proxyConfiguration` (type: `object`):

Leave off for a simple run. Turn on Apify Proxy here when you want Apify to route requests through its network - useful on busy or sensitive targets.

## Actor input object example

```json
{
  "urls": [
    "Mark Zuckerberg"
  ],
  "maxItems": 10,
  "includeReplies": true,
  "includeNestedReplies": false,
  "maxRepliesPerPost": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items in the Actor's default dataset - full posts and reply rows, with engagement counts, mentions/hashtags/urls, and quote/repost flags.

## `conversation` (type: `string`):

The same items narrowed to the conversation-focused columns - posts vs. replies (type, isChild, parentId), quote/repost flags, and engagement counts, without the raw ID/URL columns from the default view.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "Mark Zuckerberg"
    ],
    "maxItems": 10,
    "maxRepliesPerPost": 20,
    "sessionid": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/threads-search-post-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": ["Mark Zuckerberg"],
    "maxItems": 10,
    "maxRepliesPerPost": 20,
    "sessionid": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/threads-search-post-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "Mark Zuckerberg"
  ],
  "maxItems": 10,
  "maxRepliesPerPost": 20,
  "sessionid": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/threads-search-post-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/threads-search-post-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/heiNBApGqJGGwR2du/builds/dbPhOyGbS4IHM2GG4/openapi.json