# Reddit Intent Analyzer: Buying & Switching Signals (`technicaldost/reddit-buyer-intent-radar`) Actor

Analyze imported Reddit posts and comments for explicit recommendation requests, alternatives, pain points and buying-language signals. Evidence-linked research output; no direct Reddit scraping.

- **URL**: https://apify.com/technicaldost/reddit-buyer-intent-radar.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** AI, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$250.00 / 1,000 evidence reports

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

## Reddit Buyer Intent Radar — Dataset Analyzer

Find explicit recommendation requests and switching language in imported Reddit discussions. Scores measure matching phrase strength, not purchase probability. A batch without matching signals can return no findings.

### First run

**Preview the output:** run the input below with no records, dataset IDs or app IDs. It uses labeled synthetic records with no report-event fee. After the run, open **Markdown report** for the readable result or **JSON report** for integration.

```json
{
  "demoMode": true
}
```

The preview uses example.com source URLs and fictional feedback. It is a format demonstration, not customer or competitor research.

### Analyze your own data

Import Reddit posts or comments containing a text field and original sourceUrl. Keep the full discussion context when reviewing a match. If your export stores post text as `selftext`, copy it to `text`; copy `permalink` to `sourceUrl` and expand relative paths with `https://www.reddit.com`. For comment exports, preserve the original URL as `sourceUrl`. This actor does not scrape Reddit, enrich identities or send outreach.

For an existing dataset, select it with the dataset picker in the input form. The API equivalent is below; replace the placeholder before running:

```json
{
  "demoMode": false,
  "sourceType": "dataset",
  "datasetIds": [
    "YOUR_REDDIT_DATASET_ID"
  ],
  "maxRecords": 1000,
  "maxInsights": 20
}
```

You can instead paste objects into `records`. Each record should contain `text` and its original `sourceUrl`; optional fields include `id`, `platform`, `brand`, `location`, `rating`, `date`, `likes` and `title`. Supplied sources override synthetic demo mode. Dataset reads do not rerun the collector. Any separate upstream collection workflow is outside this report price.

### What comes back

One report row in the default dataset contains an `insights` array, analyzed-record count and finding count. The output links also provide `REPORT.md` and `REPORT.json` in the key-value store. Use JSON to preserve nested evidence; use the Markdown report for review.

Each discussion group includes matching source excerpts, signal tags and heuristic intent scores. These identify explicit phrasing, not verified leads, buying readiness or permission to contact.

### Record limits and sample comparison

`maxRecords` caps raw current records examined at 1–1,000 before deduplication and filtering. `maxInsights` caps findings at 1–30. A small or unmatched batch can return fewer findings, including zero. The fee is per delivered report, not per finding.

`previousDatasetId` remains in the input schema for compatibility. Prior-sample comparisons are implemented only in App Store Review Feature Roadmap; leave that field blank in this workflow.

### Pricing

**$0.25 per delivered report**, covering at most 1,000 current raw records. This includes analysis of inline records, existing datasets or native Apple reviews. The actor uses one `report-delivered` event and no additional dataset-row event. See the Pricing tab for the current platform price.

Synthetic previews on the imported-data workflows have no report-event fee. The App Store live sample uses actual reviews and the normal $0.25 report price.

### Method and recurring use

Analysis uses deterministic English phrase/rating rules and text grouping; no generative AI model is called. Scores and draft actions are research aids. Sarcasm, negation, uncommon phrasing and multilingual text can be misclassified. Inspect supporting evidence before acting. Topics can overlap, so their percentages must not be added together. Samples do not establish market-wide demand, product capabilities or future business results.

Use the Actor API or Apify MCP with the same input schema. Imported datasets are snapshots; provide fresh source data for repeated analysis. This actor does not directly scrape YouTube, Reddit or Google Maps or start third-party collectors. No external model key is required.

### Local run

Requires Node.js 22 or newer. Run `npm ci`, then `npm start`. The Dockerfile uses `apify/actor-node:22`.

# Actor input Schema

## `demoMode` (type: `boolean`):

With records, datasetIds and appIds empty, use labeled synthetic records with no report-event fee. Any supplied source overrides this preview and uses the normal report price.

## `records` (type: `array`):

Import Reddit posts or comments containing a text field and original sourceUrl. Keep the full discussion context when reviewing a match. This actor does not scrape Reddit, enrich identities or send outreach. Supported optional fields include id, date, rating and likes. If needed, map selftext to text and permalink to an absolute sourceUrl before importing.

## `datasetIds` (type: `array`):

Select your existing source dataset from the picker. It is read with READ permission; its collector is not rerun.

## `sourceType` (type: `string`):

Use imported datasets or inline records for this workflow. Native Apple review feeds are an optional shared input adapter; they do not collect Reddit discussions.

## `appIds` (type: `array`):

Optional Apple feed adapter only; not needed for this workflow’s imported data. Numeric Apple App Store app IDs, as strings. Uses public customer-review feeds; feed availability and historical coverage vary by app and storefront.

## `country` (type: `string`):

Optional Apple feed adapter only; not needed for this workflow’s imported data. Two-letter Apple storefront country code. Only used for app-store collection; analysis rules are optimized for English text.

## `maxPages` (type: `integer`):

Optional Apple feed adapter only; not needed for this workflow’s imported data. Maximum review-feed pages requested per app; the source can return fewer pages. The overall record cap still applies.

## `maxRecords` (type: `integer`):

Maximum raw source records read/examined across this run, before deduplication and filtering. Launch limit is 1,000. This is not a guarantee of 1,000 unique reviews or insights.

## `maxInsights` (type: `integer`):

Upper limit on ranked findings inside the single report. Results can be fewer when the supplied evidence does not support additional findings.

## `brand` (type: `string`):

Optional label for the business/product under study. For competitor comparison, provide a brand on each record to preserve distinct groups; service records can also provide location.

## `previousDatasetId` (type: `string`):

App Roadmap comparison only. This workflow does not produce prior-sample comparisons; leave this field blank. Kept for input compatibility.

## Actor input object example

```json
{
  "demoMode": true,
  "sourceType": "dataset",
  "country": "us",
  "maxPages": 2,
  "maxRecords": 1000,
  "maxInsights": 20
}
```

# Actor output Schema

## `report` (type: `string`):

No description

## `markdown` (type: `string`):

No description

## `dataset` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/reddit-buyer-intent-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/reddit-buyer-intent-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 '{}' |
apify call technicaldost/reddit-buyer-intent-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,technicaldost/reddit-buyer-intent-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/vJApLVd62jiOa9xof/builds/5dyZrc9OPjZ33cw1e/openapi.json