Threads Scraper: Keyword Search & Exact Match

Use this Threads scraper to collect public Threads posts by keyword or exact phrase. Search up to five queries, apply a publication-date filter, and export posts to JSON, CSV, or Excel. Each result includes its post URL, author, text, dates, available engagement counts, and matching queries.

Use it to review brand mentions, track public topic discussions, or prepare a dataset for analysis. Saved history can skip posts returned by earlier runs. The same workflow works in Apify Console and through the Threads scraper API.

Try a configured example: export Shopify mentions to CSV or monitor unique brand mentions. Replace Shopify with your own brand before running. These examples create no schedule or alerts.

Threads scraper features and output

Need	Supported behavior
Keyword search	Up to five queries in one batch
Exact phrase search	Case-normalized phrase matching in post text
Date filtering	Keep returned posts at or after a UTC timestamp
Duplicate removal	Combine repeated post codes across queries
Repeat monitoring	Skip saved post codes for up to 30 days or 5,000 entries
Export	Download the saved dataset as JSON, CSV, or Excel
Data fields	Text, author, post URL, publication time, available counts, and query attribution

Public source coverage is partial. Some queries return no posts even when another source can find matches. Use this tool for a bounded sample of public top-search results. It does not provide complete historical or recent search.

Threads scraper pricing

Each run costs $0.01 plus $0.002 per saved post ($2 per 1,000 posts). A run with ten saved posts costs $0.03. A run with no saved posts costs $0.01. The run fee also applies to failed runs and jobs that exit with history_busy. Rejected posts and skipped duplicates do not create saved-post charges.

Memory is fixed at 1 GB. The maximum output is 50 posts, so the event charge is at most $0.11 per run at these settings. Set a spending limit to stop output sooner. The minimum allowed spending limit is $0.012. Platform usage is not added as a separate customer charge for standard runs.

How to scrape Threads posts

1. Open the Actor in Apify Console and enter one to five search queries.
2. Select a text rule. Add a date cutoff or saved history if needed.
3. Set the result caps and spending limit, then start the run.
4. Review the run summary and download the retained posts.

Start with this configuration. Set postedAfter to the beginning of the time window you need.

{
  "queries": ["Airbnb refund", "Shopify"],
  "matchMode": "all_terms",
  "postedAfter": "2026-10-18T00:00:00Z",
  "maxResults": 30,
  "maxResultsPerQuery": 20,
  "onlyNewPosts": true,
  "stateStoreName": "my-topic-monitor"
}

Use the query list in the input form. Each query needs 1–200 characters. The list accepts up to five queries. Repeated queries are searched once. The tool uses one browser for the batch. API clients can also use the older query field for one query. Do not supply both forms.

maxResults caps the saved rows across the whole run, from 1 to 50. maxResultsPerQuery caps matching source candidates before batch and history exclusions. It also accepts 1–50. These are caps, not guaranteed counts. Query order sets priority. The run summary names queries skipped because of a work or result limit.

Threads keyword and exact-phrase filters

• all_terms, the default, requires every query word in the post text. It uses whole Unicode letter-and-number words. refund does not match refunded. It does not match only an author name or translate words.
• exact_phrase requires the same phrase and punctuation. It normalizes case, Unicode compatibility characters, and repeated whitespace. Airbnb refund matches AIRBNB refund, but not Airbnb, refund.
• source keeps the source's relevance choices without a text filter.

Matching evidence appears in every row. A text match does not guarantee semantic relevance. For queries whose punctuation changes the meaning, use exact_phrase.

postedAfter is an optional inclusive publication-time cutoff in Coordinated Universal Time (UTC). Use a timestamp such as 2026-10-18T00:00:00Z. Omit it to keep all returned dates. This filter does not recover posts absent from the source. Saved output is ordered by publication time, newest first. The source search still uses its top view.

Remove duplicate Threads posts and skip prior results

Each post code appears once across the batch. sourceQueries lists the searches that returned that post. matchedQueries lists the supplied queries that pass the text rule. In source mode, it lists only the searches that returned the post. query and match preserve the first discovery query and its evidence.

Set onlyNewPosts and reuse a dedicated stateStoreName for repeat runs. History applies across queries that share the store. It retains up to 5,000 saved post codes for 30 days. Old or evicted codes can appear again. Use different stores for independent workflows. New means absent from saved history, not newly published.

A shared history guard permits one cloud job at a time per store. An overlapping job exits with history_busy before browser work. Retry it after the active job finishes. Cloud guards expire after 120 seconds if a job stops unexpectedly. The process safety limit is 85 seconds.

History is saved after each successful output write. Concurrent cloud jobs cannot update the same history while the guard is held. An interruption between output and history writes can still return a post again. The tool does not promise exactly-once delivery. A history-write error stops further output.

Export Threads data to JSON, CSV, or Excel

Use the Results, Download CSV, or Download Excel links after the run. JSON, CSV, and Excel contain the same saved posts. No second extraction run is needed for another format.

Each record contains its post code and ID, URL, author username and display name, text, publication time, media-presence flag, available engagement counts, query attribution, matching evidence, and collection time. Quoted posts and thread replies are not added as extra search results. Missing optional source fields remain null and appear in missingFields.

This output example uses synthetic data:

{
  "postCode": "Example123",
  "postId": "123456789",
  "url": "https://www.threads.com/@example/post/Example123",
  "username": "example",
  "authorName": "Example",
  "text": "Airbnb refund arrived.",
  "publishedAt": "2026-10-25T06:00:00.000Z",
  "hasMedia": false,
  "likeCount": 0,
  "replyCount": null,
  "repostCount": null,
  "quoteCount": 0,
  "query": "Airbnb refund",
  "sort": "top",
  "scrapedAt": "2026-10-25T06:45:00.000Z",
  "sourceQueries": ["Airbnb refund"],
  "matchedQueries": ["Airbnb refund"],
  "missingFields": ["replyCount", "repostCount"],
  "match": {
    "mode": "all_terms",
    "scope": "post_text",
    "terms": ["airbnb", "refund"],
    "matchedTerms": ["airbnb", "refund"],
    "exactPhrase": true
  }
}

Read RUN_SUMMARY for per-query candidates, excluded matches, source errors, skipped queries, history exclusions, and saved rows. A failed query does not discard records from successful queries. partial_failure identifies such runs. Output or history-write errors fail the run. The coverage field always says partial.

source_empty means the source returned no candidates. no_matching_results means candidates failed the filters. no_new_matching_results means matching candidates were in history. These are valid empty outcomes. They do not prove that no matching posts exist.

Filters and duplicate checks run before dataset writes and any dataset-item charges. Browser work, history storage, and empty runs still use platform resources. The run stops at its result cap, spending limit, or work deadline. No schedule is created.

Threads keyword search API

Use the Apify REST API to start this Threads scraper from a script or an HTTP step in an automation workflow. Set your Apify API token in APIFY_TOKEN.

This request allows up to ten saved posts. At the configured prices, its maximum event charge is $0.03.

curl --request POST \
  'https://api.apify.com/v2/acts/jungle_cleric~money-venture-threads-search/runs?maxTotalChargeUsd=0.03' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"queries":["Shopify"],"matchMode":"all_terms","maxResults":10,"maxResultsPerQuery":10}'

The response contains data.id for the run and data.defaultDatasetId for its output. Check GET /v2/actor-runs/{runId} until the run finishes. For a successful run, download GET /v2/datasets/{datasetId}/items. Add ?format=csv or ?format=xlsx for another export format. Use the same authorization header. The run summary explains any skipped queries or partial output.

Use the Threads scraper from Python

This standard-library example starts a run and prints its ID. It does not wait for the dataset to finish.

import json
import os
import urllib.request

url = "https://api.apify.com/v2/acts/jungle_cleric~money-venture-threads-search/runs?maxTotalChargeUsd=0.03"
payload = {"queries": ["Shopify"], "maxResults": 10, "maxResultsPerQuery": 10}
request = urllib.request.Request(
    url,
    data=json.dumps(payload).encode(),
    headers={
        "Authorization": "Bearer " + os.environ["APIFY_TOKEN"],
        "Content-Type": "application/json",
    },
    method="POST",
)
with urllib.request.urlopen(request) as response:
    print(json.load(response)["data"]["id"])

Threads scraper FAQ

Does this scraper need a Threads login?

No Threads account or cookies are required. The scraper reads public top-search results. Public access can return fewer posts than another provider, or no posts for some queries.

Can I search Threads for an exact phrase?

Set matchMode to exact_phrase. The saved post text must contain the phrase with the same punctuation. Case and repeated whitespace are normalized. The filter applies to returned candidates; it does not recover posts missing from the public source.

How do I avoid duplicate Threads results?

Post codes are combined across queries before output. Enable onlyNewPosts and reuse a dedicated stateStoreName to skip posts saved by earlier runs. History limits and interrupted-write behavior are described above.

Can I monitor brand mentions on Threads?

Use brand names as queries and enable saved history for repeat runs. Review the post text and matchedQueries to see which words matched. An Apify Schedule can start recurring runs if you configure one. This Actor creates no schedule or alerts by itself. Literal matching does not classify sentiment or intent.

Is the Threads scraper API the official Threads API?

This is an Apify-hosted browser scraper. Its REST API starts collection runs and exports their datasets. It is not Meta's official Threads API.

Can AI agents use this Threads scraper?

The Actor is public and uses limited permissions. An AI client can use the Apify MCP server to discover and run Actors. Identify this Actor as jungle_cleric/money-venture-threads-search. Its input schema describes the query and filter controls. Its dataset schema describes the output fields. Account authorization and spending limits still apply.

Does it return every recent Threads post?

No. Results are a partial public top-search sample. postedAfter filters publication dates and saved rows are ordered newest first. Neither behavior makes source coverage complete. The run summary lists limits and query failures.

Where can I report a failed search?

Use the Actor's Issues tab. Include the query, run ID, stop reason, and expected output so the problem can be checked.

Local development

npm ci --ignore-scripts
npm test
APIFY_DISABLE_KEYRING=1 apify run

Create storage/key_value_stores/default/INPUT.json first. Install local Chrome or the matching Playwright browser. Local storage is excluded from Git. The local history guard uses a directory under storage/history-locks. If a local process stops without cleanup, stop other local jobs before removing its stale guard directory.

The collector loads public structured search data without account cookies or purchased proxies. It blocks images, media, fonts, and stylesheets. Browser source changes, regional differences, pagination limits, and production costs need continued checks.