# Threads Conversation Intelligence – Search, Replies & Monitor (`lexxer/threads-conversation-intelligence`) Actor

Search public Threads posts, collect profile activity and visible reply conversations, and emit only new results on scheduled runs. No login or developer token required.

- **URL**: https://apify.com/lexxer/threads-conversation-intelligence.md
- **Developed by:** [Lexxer ​](https://apify.com/lexxer) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 public search requests

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Conversation Intelligence – Search, Replies & Monitor

Turn public Threads conversations into clean, monitor-ready data without a Threads login, browser session, or developer token.

Use one Actor for brand research, trend discovery, creator tracking, conversation analysis, customer-language research, and scheduled alerts. It combines several public search views, removes duplicates, preserves reply relationships where the public page exposes them, and reports partial coverage instead of quietly pretending a conversation is complete.

### Start free

The default **Free cached preview** returns three representative records without contacting Threads and without a paid event. It lets you inspect the dataset shape before paying for a live query.

For live collection, select an operation and add your search terms, profiles, or post URLs.

### What you can do

#### Search public conversations

- Search keywords, phrases, hashtags, products, competitors, or topics
- Merge Default, Recent, and Top search views
- Remove duplicate posts automatically
- Capture post text, author, timestamp, engagement, links, and media

#### Research public profiles

- Resolve public profile identity and biography
- Collect follower and verification information exposed publicly
- Return the profile's currently visible recent posts
- Distinguish unavailable or private targets from successful empty results

#### Analyze a post and its replies

- Return the root post and visible public replies
- Link direct replies to the root
- Infer deeper reply parents by the referenced public author when an exact parent post ID is not exposed
- Include a confidence label for every inferred link
- Compare the post's reported reply count with the number actually collected

#### Monitor only new results

Choose **Only new results**, select Search, Profile, or Conversation, and run the same Actor task on an Apify schedule. The Actor stores a bounded ID history and emits only records it has not seen before.

The first monitor run establishes the baseline and returns the currently visible records. Later runs return only additions.

### Honest coverage

Threads often reports more replies than it exposes to a logged-out public page. Every conversation therefore includes a `coverage` record with:

- `reportedReplyCount`
- `collectedReplyCount`
- `visibleCoveragePercent`
- `complete`
- a plain-language coverage note

This makes incomplete public coverage measurable instead of invisible.

### Pricing

The cached preview is free. Live use is charged per successful target, not per result row:

| Live action | Price per target |
| --- | ---: |
| Search term | $0.001 |
| Public profile | $0.001 |
| Post conversation | $0.003 |
| Only-new monitor target | $0.001 |

A tiny Actor-start event covers the fixed cost of beginning a run; Apify currently calculates it at $0.00005 for this 256 MB Actor. A failed target is not charged. A search term can return many deduplicated records for one event. A normal one-target search therefore costs about $0.00105, while a conversation costs about $0.00305. Apify may display the equivalent per 1,000 events in its standard pricing table.

### Input examples

#### Search a market topic

```json
{
  "operation": "search",
  "searchTerms": ["electric vehicle", "EV charging"],
  "searchSurfaces": ["default", "recent", "top"],
  "maxResults": 50
}
```

#### Collect a public profile

```json
{
  "operation": "profile",
  "profiles": ["@natgeo"],
  "maxResults": 30
}
```

#### Analyze visible replies

```json
{
  "operation": "conversation",
  "postUrls": ["https://www.threads.com/@natgeo/post/Db5pTtZFAmB"],
  "maxReplies": 100
}
```

#### Publish a scheduled search monitor task

```json
{
  "operation": "monitor",
  "monitorType": "search",
  "searchTerms": ["your brand", "your product"],
  "searchSurfaces": ["recent"],
  "maxResults": 100
}
```

### Output

Rows use one of three types:

- `profile` — public identity, biography, follower information, and verification
- `post` — content, author, engagement, media, permalink, reply relationship, and timestamps
- `coverage` — reported versus collected conversation depth

Every live row also carries `queryType`, `queryTarget`, and `monitorRun`, so results from multi-target runs remain easy to filter.

The run's `OUTPUT` record contains target success/failure counts, retry attempts, response sizes, emitted rows, billing count, and errors. One broken target does not discard successful targets from the same run.

### Reliability design

- Reads server-rendered public pages instead of fragile visual selectors
- Validates that a response contains real structured Threads data rather than a login shell
- Retries timeouts, rate limits, server errors, and incomplete responses
- Uses conservative bounded concurrency
- Uses Apify Proxy by default in the cloud and rotates routing on retries; API users can disable it explicitly
- Keeps successful search views when another selected view is temporarily rate-limited
- Deduplicates across search views and repeated embedded payloads
- Keeps per-target failures visible in the run summary

### Public-data boundary

This Actor reads only information exposed on public Threads pages. It does not log in, access private accounts, solve CAPTCHAs, send messages, like content, or automate user accounts.

Public availability does not replace your own legal obligations. Use the Actor only where your purpose, collection, storage, and processing comply with applicable law, the rights of data subjects, and the relevant platform terms. Site behavior and public coverage can change.

Threads and Meta are trademarks of their respective owners. This Actor is an independent tool and is not affiliated with or endorsed by Meta.

### Support

When reporting a problem, include the public target, run ID, operation, and whether the failure affected every target or only one. Do not send login cookies, access tokens, or private content.

# Actor input Schema

## `operation` (type: `string`):

The cached preview makes no Threads request and is never charged.

## `monitorType` (type: `string`):

Used only for Only new results. The first run establishes the baseline and returns the currently visible records.

## `searchTerms` (type: `array`):

Keywords, phrases, hashtags, products, brands, or topics. Up to 10 per run.

## `profiles` (type: `array`):

Handles or profile URLs, for example @natgeo. Up to 10 per run.

## `postUrls` (type: `array`):

Full Threads post URLs. Up to 20 conversations per run.

## `searchSurfaces` (type: `array`):

Combining views increases useful coverage; duplicate posts are removed automatically.

## `maxResults` (type: `integer`):

Limits search hits or recent profile posts after duplicates are removed.

## `maxReplies` (type: `integer`):

Threads may expose fewer public replies than its reported count; the output always reports the difference.

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

Apify Proxy is enabled by default for cloud reliability. It is platform usage, not a paid third-party data API.

## `concurrency` (type: `integer`):

The conservative default balances speed and public-site reliability.

## `requestTimeoutSecs` (type: `integer`):

Seconds allowed for each public page request.

## `retries` (type: `integer`):

Retries rate limits, server errors, timeouts, and incomplete page shells.

## Actor input object example

```json
{
  "operation": "demo",
  "monitorType": "search",
  "searchTerms": [
    "artificial intelligence"
  ],
  "profiles": [
    "@natgeo"
  ],
  "postUrls": [
    "https://www.threads.com/@natgeo/post/Db5pTtZFAmB"
  ],
  "searchSurfaces": [
    "default",
    "recent",
    "top"
  ],
  "maxResults": 50,
  "maxReplies": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "concurrency": 3,
  "requestTimeoutSecs": 45,
  "retries": 3
}
```

# Actor output Schema

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

Live target events are charged only after the target returns a validated public page.

## `summary` (type: `string`):

Target success, failure, emitted-row, retry, page-size, and coverage details.

# 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 = {
    "searchTerms": [
        "artificial intelligence"
    ],
    "profiles": [
        "@natgeo"
    ],
    "postUrls": [
        "https://www.threads.com/@natgeo/post/Db5pTtZFAmB"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexxer/threads-conversation-intelligence").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 = {
    "searchTerms": ["artificial intelligence"],
    "profiles": ["@natgeo"],
    "postUrls": ["https://www.threads.com/@natgeo/post/Db5pTtZFAmB"],
}

# Run the Actor and wait for it to finish
run = client.actor("lexxer/threads-conversation-intelligence").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 '{
  "searchTerms": [
    "artificial intelligence"
  ],
  "profiles": [
    "@natgeo"
  ],
  "postUrls": [
    "https://www.threads.com/@natgeo/post/Db5pTtZFAmB"
  ]
}' |
apify call lexxer/threads-conversation-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lexxer/threads-conversation-intelligence"
        }
    }
}

```

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/iu48EdNuUo2BTIDdo/builds/sNTIhYtRKD7qoka2U/openapi.json