Threads Search Scraper

Search public Threads posts by keyword or hashtag and export clean data for monitoring, research, trend tracking, and content analysis. No Threads login is required.

What It Helps You Do

• Monitor public conversations around brands, products, competitors, and campaigns
• Track recent or popular posts for social listening and market research
• Collect engagement fields such as likes, replies, reposts, shares, and public view counts when available
• Export author, profile, media, hashtag, mention, and link fields for analysis

How To Use

1. Enter one or more keywords or hashtags
2. Choose Top / Popular or Recent / Newest first
3. Choose the maximum number of posts to collect for each keyword
4. Optionally add a date range
5. Start the Actor and export the results from the dataset

Input Example

{
  "keywords": ["AI", "#startup", "台北 餐廳"],
  "search_filter": "recent",
  "max_posts": 50
}

Example With a Date Range

{
  "keywords": ["OpenAI"],
  "search_filter": "top",
  "start_date": "2026-01-01",
  "end_date": "2026-02-28",
  "max_posts": 100
}

Input

Field	Description
keywords	Keywords or hashtags to search, up to 20 per run. The # is optional, and a leading @ is dropped so @openai searches for openai. Words, not links: a post or profile address is skipped and named, because the search cannot look for one.
max_posts	Maximum posts per keyword, from 10 to 1000, so 3 keywords at 50 can return up to 150 rows. Actual results depend on public availability at run time.
search_filter	top for popular posts, or recent for the newest matching public posts.
search_language	Optional. english (default), japanese, or chinese (Traditional). Asks for more of the posts written in that language and fewer of the rest. Many keywords will not change at all.
start_date	Optional start date, in UTC. Use YYYY-MM-DD, or a relative value such as 7 days meaning 7 days ago.
end_date	Optional end date, in UTC, and the whole day is included. Use YYYY-MM-DD — a relative value here counts backwards from today too, which is rarely what you want as an end date.

Output

Each dataset row is one public Threads post. Common fields include:

Field	Description
post_url	Direct URL of the Threads post
post_code	Threads post identifier
text_content	Post text
created_at	Post timestamp when available
username	Author username
user_id	Author's stable account ID when available
display_name	Author display name
profile_url	Author profile URL
followers_count	Public follower count when available
bio	Public author bio when available
like_count	Likes when available
reply_count	Replies when available
repost_count	Reposts when available
quote_count	Quotes when available
share_count	Shares when available
view_count	Public views when available
view_count_status	Why a row has or does not have a view count: available, not_public_yet for a post that is still too new, or not_checked when no count was read for that post this run
has_media	Whether media is attached
media_type	Media type when available
media_url	Primary media URL when available
media_urls	All media URLs, in carousel order, when available
hashtags	Hashtags used in the post, each listed once
mentions	Mentions found in the post text, each listed once
mentioned_accounts	Users the post mentions, each paired with their account ID
music_artist	Artist of the track the post was published with, when it has one
music_title	Title of that track
music_song_id	Identifier of that track, for grouping posts that use the same one
search_keyword	Keyword or hashtag associated with the row
search_filter	Sort order used for the run
search_language	Result language the run asked for
keyword_match	Whether the post appears relevant to the searched keyword. A filtering aid, not an exact-match guarantee
scraped_at	When the row was collected

The dataset views group the fields most runs need. Switch to "All fields" in the Apify console to see the complete record, including hashtags, mentions, links, media details and sticker fields.

Output Example

Field names and value formats below are real; the values themselves are placeholders.

{
  "record_type": "post",
  "post_url": "https://www.threads.com/@public_account_name/post/ABC123",
  "post_code": "ABC123",
  "text_content": "Example public Threads post about AI research.",
  "created_at": "2026-02-15T08:30:00+00:00",
  "username": "public_account_name",
  "user_id": "10000000000",
  "display_name": "Public Account Name",
  "profile_url": "https://www.threads.com/@public_account_name",
  "followers_count": 12500,
  "bio": "Public profile bio",
  "like_count": 152,
  "reply_count": 18,
  "repost_count": 7,
  "quote_count": 2,
  "share_count": 4,
  "view_count": 4200,
  "view_count_status": "available",
  "has_media": true,
  "media_type": "photo",
  "media_url": "https://example.com/image.jpg",
  "media_urls": [],
  "hashtags": ["AI"],
  "mentions": ["mentioned_account_name"],
  "mentioned_accounts": [{ "username": "mentioned_account_name", "user_id": "20000000000" }],
  "music_artist": "Example Artist",
  "music_title": "Example Track",
  "music_song_id": "1000000000000000",
  "search_keyword": "AI",
  "search_filter": "top",
  "keyword_match": true,
  "scraped_at": "2026-02-18T12:00:00+00:00"
}

Dataset Views

• Posts: post text, URL, date, author, media, and search fields
• Engagement: likes, replies, reposts, quotes, shares, and public views
• Authors: author fields attached to search results
• Bio Links: public author bio links and contact fields when present

How to Read Run Results

Every run that is allowed to finish writes a short summary (the OUTPUT record) next to your dataset. The Actor stops itself shortly before the run timeout when the timeout leaves room for that, and reports run_time_limit; a run the platform cuts off before it has wrapped up keeps the rows already delivered but writes no summary. Three fields tell you what you got:

• collection_status — complete means the run delivered everything it found for your request. partial means something was left short.
• result_quality — how completely the extra per-post signals could be filled in. complete means every delivered post's page was read for them; a page that was read can still show no view count, and that row says so itself in view_count_status (not_public_yet for a post still too new, not_checked when no count was read for it this run). partial means some rows left without their extra signals being read at all, such as when a run was stopped early, or an author's profile details could not be loaded. It is about the rows you received, not about how many.
• reason — a short word for how the run ended, when one can be named. It appears both when a run came up short and when a search simply had nothing to return. A partial run can have no reason to give; the rows each keyword received, against the number you asked for, then show where it came up short. The reasons are:
  • no_results — nothing was there to deliver for this request: the keyword had no public matches, or none within the date range or about the keyword. This comes with complete: nothing was missed. Try a broader keyword or a different sort order.
  • results_hidden — Threads keeps the results for every keyword in the run back: its answer carries no posts and marks them as held back, with a notice that speaks of well-being or sensitive content. The source answered, so this comes with complete; hidden_items names the keywords. Try a related keyword.
  • details_incomplete — some posts were found but left out because their public details could not be confirmed this run; the posts that could be confirmed were delivered. When none of a keyword's posts could be confirmed, the run says so rather than reporting an empty keyword.
  • temporarily_unavailable — part of the collection could not be finished this time: the search stopped answering for a keyword before its count was reached, or the run was interrupted partway through. The rows collected were delivered, after an interruption as many as its remaining time allowed, and some of them arrive without the extra per-post signals or the author's profile details (their view_count_status reads not_checked). Running it again may get further; a new run collects from the beginning.
  • stopped_by_request — the run was stopped from the Apify console before it finished. The rows it had collected were delivered, as many as the time after the stop allowed, some of them without the extra per-post signals or the author's profile details; a keyword the stop left with no rows at all is listed in skipped_items. Running it again collects from the beginning, so narrow the input rather than repeating the same run.
  • run_time_limit — the run reached its own time limit and stopped early so that the rows it had collected would still be delivered, some of them without the extra per-post signals or the author's profile details. Repeating the run as-is meets the same time limit; give it more time, or search fewer keywords at once.
  • search_depth_reached — for one or more keywords the search went as deep as this run reaches while posts were still turning up; the rows each keyword received show which. Without a date range, a keyword only a few posts short of its count is searched a little deeper, not all the way. Repeating the run reaches the same depth; to collect more, set the date range to the period you still need, or split a long range into shorter ones.
  • scraping_errors — one or more keywords hit an error; any other keywords still delivered. Check failed_reasons for the keyword-by-keyword picture.
  • storage_incomplete / storage_unavailable — some or all results could not be saved. A new run collects from the beginning rather than continuing this one, and writes to its own dataset; when a run continues after it was stopped or moved, it does not write again the posts it had recorded as delivered.
  • invalid_input — the run stopped before searching; the message explains what to change.
  • unexpected_error — something went wrong that the Actor could not put in any of the categories above. The run ends without delivering the remaining results.

A run that reaches the maximum cost set for it delivers the rows that fit within that limit and reports partial; the run message says the limit was reached, and a keyword the limit left with no rows at all is listed in skipped_items.

If you resurrect a stopped run from the Apify console, it goes on to the keywords it still owes and does not write again the posts it already delivered. Rows that left before their extra signals were read stay as they are, so such a run can finish with every keyword delivered and a partial result quality.

For multi-keyword runs, failed_items lists any keyword that was searched but could not finish, and failed_reasons gives each one a short cause: request_timeout and temporarily_unavailable mean that keyword was interrupted rather than empty; request_unavailable means the public search page could not be read for that keyword just then; save_unavailable / save_incomplete concern saving rather than searching; details_incomplete means some of the keyword's posts were left out because their public details could not be confirmed; unexpected_error covers anything that did not fit the categories above. skipped_items lists the keywords a stop, or the maximum cost set for the run, left with no rows at all, whether before they were searched or before any of their results could be delivered, so you can run exactly those again. hidden_items lists the keywords Threads keeps the results back for (its answer carries no posts and marks them as held back); those keywords count as completed and are not errors.

A quiet keyword is not an error: a keyword with no public matches simply contributes zero rows, the run still succeeds, and the summary says so plainly.

Tips

• Use short, focused keywords for broader discovery
• Use recent for monitoring newer public conversations
• Use date filters when you need a specific research window
• Use keyword_match as a filtering aid to separate posts that name your keyword from broader related results; it is a guide, not an exact-match guarantee
• Group by music_song_id to see which posts share a track; a post without a track leaves these columns empty
• Searching several keywords at once? Sort the exported created_at values for one combined timeline

Limitations

• Threads can change what it shows publicly over time
• Some posts are left out when their public details cannot be confirmed; others arrive with individual fields empty
• Very new, deleted, private, restricted, or partially available posts may return incomplete fields
• Search ranking may include broadly related posts, not only exact keyword matches
• A keyword can return fewer rows than requested; the run summary names the reason when it can

Need Another Threads Workflow?

• Threads Scraper - Posts, Reposts, Replies, Profiles & Search: collect public posts, search keywords, discover profiles, and export account data.
• Threads Replies Scraper: collect public replies and comments for conversation analysis.

FAQ

Does this require a Threads login?

No. The Actor is designed for publicly accessible Threads data and does not require you to provide a Threads account.

Why did I get fewer results than requested?

Result count varies by keyword and by run. A broader keyword or a different sort order can return more. For posts from a particular period, set the date range to that period: it asks for a different stretch of results than a run with no dates. Repeating the same input asks for the same stretch of results again, so change the keyword, the sort order or the dates rather than running it again unchanged. When you search several keywords at once, a post found by more than one of them is delivered at most once, under the earliest keyword in your list that found it, so a later overlapping keyword can show fewer rows.

Why did a keyword come back empty when Threads has posts about it?

For some search words Threads keeps the results back: its answer carries no posts and marks them as held back, with a notice that speaks of well-being or sensitive content (the Threads website itself shows "No results" for such a word). Those words come back with no rows; the run summary names them in hidden_items, and reports results_hidden when every keyword in the run was held back. Try a related keyword.

Why are some fields empty?

Some posts and profiles expose only partial public data. An empty field means the information was not public, was not available at collection time, or the run was stopped before that detail was read (the row's view_count_status then reads not_checked).

Can I ask for results in a particular language?

Yes. Set search_language to japanese or chinese (Traditional) and the run asks Threads for more of the posts written in that language. english is the default and keeps the behaviour every earlier run had. It is a preference, not a filter: posts in other languages can still appear, and a keyword only one language writes in returns the same posts whichever setting you choose. It is most useful when the same word is written the same way in several languages.

Are top and recent exact filters?

They reflect the public search ordering available at run time. recent prioritises the newest matching public posts, and some related older posts may still appear. When you search several keywords at once, sort the exported created_at values for one combined timeline.

Disclaimer

Use this Actor responsibly and ensure your usage complies with applicable laws, platform terms, and your organization's policies. Data availability and accuracy may vary over time.

Keywords: Threads Search Scraper, Threads keyword search, Threads hashtag search, Threads data scraper, Meta Threads scraper, Threads post extractor, Threads engagement metrics, Threads monitoring, Threads analytics, social listening, social media monitoring, competitor research, trend research, market research, brand monitoring, public Threads data, export Threads posts, OpenClaw, Claude Code, Gemini, Antigravity, Codex, ChatGPT