# X Industry Pain & Automation Opportunity Radar (`nexascout/nexascout-x-industry-pain-radar`) Actor

Turn public X conversations into evidence-backed business pain clusters and automation opportunities. Search recurring workflow problems, expand useful threads, deduplicate evidence, score demand, and export actionable opportunity records. Bring your own X API Bearer Token.

- **URL**: https://apify.com/nexascout/nexascout-x-industry-pain-radar.md
- **Developed by:** [NexaScout](https://apify.com/nexascout) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 automation opportunities

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## X Industry Pain & Automation Opportunity Radar

Turn public X conversations into evidence-backed business pain clusters and automation opportunities.

Instead of returning a raw feed of posts, this Actor searches focused pain queries, filters noise, expands useful conversations, clusters recurring problems, and produces structured opportunity records for product research, automation discovery, and market intelligence.

### What this Actor does

1. Generates short pain-oriented X queries for the industry you provide.
2. Collects public posts through the official X API.
3. Deduplicates overlapping evidence.
4. Classifies likely business pain versus obvious noise, promotion, hiring posts, and link-only content.
5. Expands a bounded number of useful conversations for additional evidence.
6. Clusters recurring pain themes across independent authors.
7. Produces evidence-backed automation opportunity records.

The low-level Search and Conversation Actors are orchestrated automatically. You run only this Actor.

### Bring your own X API token

The Radar uses a **BYOT (bring your own token)** model.

Enter your X Developer **Bearer Token** in the `bearerToken` field. Apify encrypts the field before storing the run input.

Important:

- X API usage is billed by X to the developer account that issued your token.
- Store users never use a NexaScout X credential.
- The Radar forwards the token only to the fixed X Search and Conversation data-layer Actors.
- Public input cannot redirect the token to an arbitrary child Actor.
- Child overrides cannot replace the canonical secret token.
- Live low-level requests are locked to the official X API host.

### Quick start

```json
{
  "industries": [
    "ecommerce"
  ],
  "bearerToken": "YOUR_X_BEARER_TOKEN",
  "searchMode": "recent",
  "lookbackDays": 7,
  "maxQueriesPerIndustry": 3,
  "maxPostsPerQuery": 10,
  "maxTotalPosts": 50,
  "conversationExpansionCap": 1,
  "maxRepliesPerPost": 10,
  "maxBudgetUsd": 0.25
}
```

### Main inputs

#### `industries`

One or more industries or business contexts to research.

Good examples:

- `ecommerce`
- `commercial real estate`
- `recruiting`
- `marketing agencies`
- `B2B sales`
- `property management`
- `accounting firms`

#### `bearerToken`

Your X Developer Bearer Token.

#### `lookbackDays`

Research window. Recent-search mode is limited by the X endpoint's available recent window.

#### Research limits

Use these fields to control scope and spend:

- `maxQueriesPerIndustry`
- `maxPostsPerQuery`
- `maxTotalPosts`
- `conversationExpansionCap`
- `maxRepliesPerPost`
- `maxBudgetUsd`

`maxBudgetUsd` is a conservative orchestration guard based on configured X-read assumptions. It is not a replacement for X billing controls or Apify's own max-cost-per-run setting.

### Opportunity output

The default dataset contains opportunity records such as:

- industry
- recurring pain
- recommended implementation path
- evidence count
- independent author count
- representative evidence URLs
- automation fit
- web-data fit
- Apify fit
- average evidence quality
- demand score

Supporting research artifacts are kept in the run's default key-value store:

- `EVIDENCE_POSTS`
- `EXPANDED_REPLIES`
- `PAIN_CLUSTERS`
- `OPPORTUNITIES`
- `RUN_SUMMARY`

### Good use cases

- Discover recurring workflow pain in an industry
- Find automation opportunities before building a product
- Collect evidence for an Apify Actor or SaaS idea
- Build a demand-research pipeline
- Identify repetitive manual work discussed by real users
- Compare pain themes across multiple industries

### How to interpret the output

The Radar is a research prioritization tool, not proof that a market is commercially viable.

Use the evidence URLs, author diversity, evidence count, and demand score together. Stronger opportunities should still be validated with customer interviews, job posts, search demand, competitor pricing, or other independent signals.

### Pricing

Apify Store charges for this Actor are separate from X API charges.

Your X Developer account is responsible for X API usage generated by your token. Keep research caps conservative until you understand the X costs for your own developer plan.

### Limitations

- Results depend on public content available through the official X API.
- Small samples can miss real demand or overrepresent a temporary discussion.
- Classification and clustering are heuristic research aids, not ground truth.
- X rate limits, search windows, and product entitlements apply.
- The Radar does not post, reply, like, follow, or automate engagement on X.

This Actor is not affiliated with X Corp.

# Changelog

This Actor's version history is a separate document: https://apify.com/nexascout/nexascout-x-industry-pain-radar/changelog.md

# Actor input Schema

## `industries` (type: `array`):

Industries to research.

## `bearerToken` (type: `string`):

Bring your own X Developer API Bearer Token for live X access. Apify encrypts this secret before storing run input. X API usage and charges apply to your own X Developer account. NexaScout does not use its X token for public/Store runs.

## `searchMode` (type: `string`):

recent uses the recent-search window; all requests full archive.

## `lookbackDays` (type: `integer`):

Recent mode clamps values above 7.

## `maxQueriesPerIndustry` (type: `integer`):

Short generated pain queries.

## `maxPostsPerQuery` (type: `integer`):

Per-query cap.

## `maxTotalPosts` (type: `integer`):

Global cap.

## `conversationExpansionCap` (type: `integer`):

Max roots expanded.

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

Reply cap.

## `maxBudgetUsd` (type: `number`):

Hard orchestration cap based on worst-case X Post reads reserved before each child call.

## `costPerQueryUsd` (type: `number`):

Optional explicit worst-case reservation per search call. Leave blank to derive from maxPostsPerQuery × xPostReadCostUsd.

## `costPerConversationUsd` (type: `number`):

Optional explicit worst-case reservation per conversation expansion. Leave blank to derive from (maxRepliesPerPost + 1) × xPostReadCostUsd.

## `minEvidenceQuality` (type: `number`):

0..1 threshold.

## `classifier` (type: `string`):

rule implemented; llm falls back to rule.

## `includeRaw` (type: `boolean`):

Retain raw payload where supported.

## `searchActorInput` (type: `object`):

Advanced child Search settings only. Credentials and child Actor routing cannot be overridden here; use bearerToken for the encrypted X credential.

## `conversationActorInput` (type: `object`):

Advanced child Conversation settings only. Credentials and child Actor routing cannot be overridden here; use bearerToken for the encrypted X credential.

## `xPostReadCostUsd` (type: `number`):

USD per Post read used for conservative budget reservation. Current X pay-per-use price is $0.005/resource; update if X pricing changes.

## Actor input object example

```json
{
  "industries": [
    "ecommerce"
  ],
  "searchMode": "recent",
  "lookbackDays": 7,
  "maxQueriesPerIndustry": 3,
  "maxPostsPerQuery": 10,
  "maxTotalPosts": 100,
  "conversationExpansionCap": 2,
  "maxRepliesPerPost": 10,
  "maxBudgetUsd": 0.05,
  "minEvidenceQuality": 0.4,
  "classifier": "rule",
  "includeRaw": false,
  "xPostReadCostUsd": 0.005
}
```

# Actor output Schema

## `opportunities` (type: `string`):

Evidence-backed opportunities in the default dataset.

## `evidencePosts` (type: `string`):

Filtered evidence posts used by the analysis.

## `expandedReplies` (type: `string`):

Conversation evidence gathered from selected threads.

## `painClusters` (type: `string`):

Recurring pain clusters before opportunity mapping.

## `runSummary` (type: `string`):

Research scope, query yield, budget reservations, warnings, and totals.

# 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 = {
    "industries": [
        "ecommerce"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/nexascout-x-industry-pain-radar").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 = { "industries": ["ecommerce"] }

# Run the Actor and wait for it to finish
run = client.actor("nexascout/nexascout-x-industry-pain-radar").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 '{
  "industries": [
    "ecommerce"
  ]
}' |
apify call nexascout/nexascout-x-industry-pain-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexascout/nexascout-x-industry-pain-radar"
        }
    }
}
```

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/Q4jF3NcY2qlOeVGcj/builds/CevGG4mTcR9EcJEqQ/openapi.json