# Reddit Pain Radar (`sebarb/reddit-pain-radar`) Actor

Score summarized public Reddit pain signals into buyer types, risk flags, product angles, and first paid offer ideas.

- **URL**: https://apify.com/sebarb/reddit-pain-radar.md
- **Developed by:** [Seba](https://apify.com/sebarb) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scored reddit pain signals

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Reddit Pain Radar

Reddit Pain Radar scores summarized public Reddit pain signals and turns them
into buyer types, pain clusters, risk flags, product angles, and first paid
offer ideas.

It is built for AI builders, micro-SaaS founders, automation consultants, and
agent operators who need demand evidence before building another product.

### What It Does

- Scores public Reddit-derived pain signals.
- Groups signals into practical pain clusters such as distribution, workflow
  chaos, speed-to-lead, report/audit demand, maintenance debt, and marketplace
  reliability.
- Identifies likely buyer type.
- Flags risky angles such as cold outreach, contact scraping, regulated/legal
  claims, platform ToS concerns, and customer-data handling.
- Suggests a product/service angle and first paid offer.

### What It Does Not Do

- It does not post, comment, message, or vote on Reddit.
- It does not extract usernames, emails, phone numbers, or contact lists.
- It does not scrape private messages or private communities.
- It does not automate cold outreach.
- It does not provide legal, financial, medical, or compliance advice.

### Input

Provide summarized public signals:

```json
{
  "dryRun": true,
  "maxResults": 10,
  "includeWatch": true,
  "signals": [
    {
      "subreddit": "r/micro_saas",
      "title": "AI-generated SaaS ideas often make little money without distribution",
      "url": "https://www.reddit.com/r/micro_saas/comments/example/",
      "summary": "Builders say distribution and talking to users are harder than coding.",
      "observed_pattern": "People need demand evidence before building.",
      "tags": ["distribution", "micro-saas"]
    }
  ]
}
````

Use paraphrased summaries and public links. Do not include usernames, private
messages, contact details, or full comment dumps.

### Output

Each dataset row includes:

- `decision`
- `urgency_score`
- `product_angle`
- `first_paid_offer`
- `buyer_type`
- `pain_types`
- `risk_flags`
- `budget_proxy`
- `subreddit`
- `title`
- `url`
- `summary`
- `next_action`

### Decision Labels

- `PACKAGE_NOW`: strong signal for a local offer/report package.
- `NEEDS_GUARDED_OFFER`: useful signal with privacy, regulated-domain, or
  implementation guardrails.
- `WATCH`: weaker or early signal; monitor until repeated evidence appears.
- `REJECT_FOR_NOW`: avoid without a safer non-contact, compliant variant.

### Example Use Cases

- Find repeated pains before building a micro-SaaS.
- Turn Reddit research into a productized service brief.
- Compare possible offers such as Operations Audit Packet, Speed-to-Lead Audit,
  Marketplace Reliability Feed, and Reddit Pain Radar.
- Create a public-safe weekly CSV/report for AI operators.

### Guardrails

This Actor is a demand-intelligence scorer. It is intentionally contact-free.
Keep outputs to summarized public behavior and links to public threads.

### Pricing Event

For public Store use, the intended pay-per-event event is `scored-signal`,
charged once per scored dataset row when the Actor is configured as a paid
Apify Actor.

# Actor input Schema

## `signals` (type: `array`):

Summarized public Reddit signals to score. Use public post URLs and paraphrased summaries; do not include usernames, private messages, contact details, or full comment dumps.

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

Maximum scored rows to output.

## `includeWatch` (type: `boolean`):

Include lower-confidence WATCH rows in the dataset.

## `dryRun` (type: `boolean`):

When enabled and no signals are supplied, score bundled sample signals. The Actor never posts, comments, messages, or extracts contacts.

## Actor input object example

```json
{
  "signals": [],
  "maxResults": 25,
  "includeWatch": true,
  "dryRun": true
}
```

# Actor output Schema

## `painSignals` (type: `string`):

Scored public-safe pain-signal rows written to the default dataset. The overview view highlights priority, buyer type, pain cluster, urgency, risk flags, product angle, first paid offer, and source URL.

# 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("sebarb/reddit-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sebarb/reddit-pain-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 sebarb/reddit-pain-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sebarb/reddit-pain-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Pain Radar",
        "description": "Score summarized public Reddit pain signals into buyer types, risk flags, product angles, and first paid offer ideas.",
        "version": "0.1",
        "x-build-id": "zCbObLNrmKq9U1EIW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sebarb~reddit-pain-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sebarb-reddit-pain-radar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sebarb~reddit-pain-radar/runs": {
            "post": {
                "operationId": "runs-sync-sebarb-reddit-pain-radar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sebarb~reddit-pain-radar/run-sync": {
            "post": {
                "operationId": "run-sync-sebarb-reddit-pain-radar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "signals",
                    "maxResults",
                    "includeWatch",
                    "dryRun"
                ],
                "properties": {
                    "signals": {
                        "title": "Pain signals",
                        "type": "array",
                        "description": "Summarized public Reddit signals to score. Use public post URLs and paraphrased summaries; do not include usernames, private messages, contact details, or full comment dumps.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "id": {
                                    "type": "string",
                                    "title": "Signal ID",
                                    "description": "Optional stable ID for this public pain signal."
                                },
                                "subreddit": {
                                    "type": "string",
                                    "title": "Subreddit",
                                    "description": "Public subreddit name where the signal was observed."
                                },
                                "title": {
                                    "type": "string",
                                    "title": "Public thread title",
                                    "description": "Public thread title or short headline for the signal."
                                },
                                "url": {
                                    "type": "string",
                                    "title": "Public Reddit URL",
                                    "description": "Public Reddit URL used only as source evidence."
                                },
                                "summary": {
                                    "type": "string",
                                    "title": "Paraphrased pain summary",
                                    "description": "Paraphrased summary of the pain. Do not include usernames, contact details, private messages, or full comment dumps."
                                },
                                "observed_pattern": {
                                    "type": "string",
                                    "title": "Observed pattern",
                                    "description": "Optional short note describing the repeated behavior or demand pattern."
                                },
                                "evidence": {
                                    "type": "array",
                                    "title": "Evidence notes",
                                    "description": "Optional short evidence notes derived from public discussion.",
                                    "items": {
                                        "type": "string"
                                    }
                                },
                                "tags": {
                                    "type": "array",
                                    "title": "Tags",
                                    "description": "Optional tags that help classify the signal.",
                                    "items": {
                                        "type": "string"
                                    }
                                }
                            },
                            "required": [
                                "subreddit",
                                "title",
                                "url",
                                "summary"
                            ]
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum scored rows to output.",
                        "default": 25
                    },
                    "includeWatch": {
                        "title": "Include watch rows",
                        "type": "boolean",
                        "description": "Include lower-confidence WATCH rows in the dataset.",
                        "default": true
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "When enabled and no signals are supplied, score bundled sample signals. The Actor never posts, comments, messages, or extracts contacts.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
