# Reddit Search & Customer Pain Monitor (`solidscrape/reddit-scraper`) Actor

Find exact matching Reddit posts and track content changes with quoted evidence, strict total budgets and deduplication. Optional live search is separately billed; process supplied records without a collector.

- **URL**: https://apify.com/solidscrape/reddit-scraper.md
- **Developed by:** [Shahryar](https://apify.com/solidscrape) (community)
- **Categories:** Social media, Business, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 distinct record inspecteds

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 Search & Customer Pain Monitor

Find Reddit posts that match your exact terms, get quoted match evidence, and track new IDs or content edits across runs. The output includes simple, transparent phrase rules for questions, problems and comparison requests. It is useful for customer research, competitor monitoring and product feedback workflows.

The live source is a fixed, tested `harshmaur/reddit-scraper` build, running in **your own Apify account and billed separately**. This Actor adds strict local text semantics, content comparisons, safe snapshot state and a shared input budget. It is independent of Reddit and that collector's developer.

### Start with a small live search

```json
{
  "mode": "live",
  "collectorCostAcknowledged": true,
  "searchQuery": "python",
  "subreddit": "python",
  "maxRecords": 5,
  "maxSpendUsd": 0.10
}
```

The prefilled example collects at most five real posts. `searchQuery` controls source discovery. To strictly filter the returned text, add `matchTerms: ["document", "parsing"]` and `matchMode: all`. This requires both literal substrings in the title/body. `any` accepts either, while `phrase` accepts exactly one term containing the required phrase. `matchEvidence` provides matching excerpts.

Save `SNAPSHOT` after a successful run and provide it as `previousSnapshot` next time. Initial records have `event: initial`, new IDs are `new`, and changes to title/body/edit timestamp produce `updated` with before/after evidence. Score fluctuations do not masquerade as content edits. Live collection returns posts only; supplied records can also be Reddit comments.

### Transparent pricing

This monitor costs **$0.008 per run + $0.0005 per distinct valid record inspected**, including unchanged or filtered records. Invalid records and duplicates are not charged as inspections. Its platform usage is included.

Live collection adds a separate collector run. The tested Free-plan ceiling is $0.02 start + $0.002 per source result. Five posts have a modeled combined price of **$0.04050** ($0.01050 monitor + $0.03000 collector). Collector plan discounts may reduce that amount. A replay with no new changes still pays to collect and inspect the records.

`maxSpendUsd` reserves this monitor's start and all `maxRecords` inspections before allocating the collector's cap. Apify's run maximum charge alone caps only the monitor; the input budget controls the combined reservation. Live mode requires `collectorCostAcknowledged: true`. The collector is fixed, limited-permission, pinned to a tested build and constrained to512MB,60seconds and a price cap. Upstream pricing or permission changes fail before collection. AI enrichment, comment expansion and external delivery are disabled in the collector.

### Process an existing export

Set `mode: inputRecords` and pass up to100 exported post/comment objects. No source collector starts. Required IDs are Reddit fullnames such as `t3_abc123` or `t1_def456`. Accepted fields include `title`, `body`/`selftext`, `createdAt`, `editedAt`, `score`, `commentsCount`, `subreddit`/`parsedCommunityName` and `postUrl`/`permalink`.

### What the signals mean

`painSignals` are **literal phrase rules**, not AI judgments or proof of buying intent. Examples include “looking for”, “not working” and “alternative to”. Every label carries the matching excerpt and `method: literal_phrase_rule`. Context, irony and negation can change meaning; review the source before acting. This Actor never contacts people automatically.

`publishedAfter`/`publishedBefore` filter inclusive exact UTC instants after collection. Use a date (midnight UTC) or an ISO timestamp with timezone. Missing dates are excluded when date filtering is requested. Source results rejected by filters may still incur collection and inspection fees.

### Limits, failures and privacy

- One query, optionally restricted to one subreddit, up to100 posts from the last week per live run. It is a bounded newest search window, not complete Reddit history or a guaranteed relevance ranking.
- The monitor enforces your local match rule on collected rows. It cannot force Reddit to discover posts absent from the source result set.
- Empty or unsuccessful live collection fails visibly and preserves prior state. `SUMMARY` explains source coverage and the separate collector receipt is in `COLLECTOR_RUN`.
- Missing records are never labeled deleted. The snapshot retains at most500 IDs; oldest entries are evicted and counted in `snapshotEvictions`.
- All inspected observations are retained, including filtered records. A previously matching post that no longer matches produces `no_longer_matches`. Snapshot filters must stay identical; changing them requires a fresh baseline.
- Author identity is excluded from normalized output. Post text can still contain personal information; collect/use data only for authorized purposes.
- Snapshot chaining requires passing the newest snapshot each run. Scheduling a task with a fixed old snapshot repeats that old comparison.
- Resurrect is disabled once work begins to avoid duplicate collector calls. Start a fresh run with the last successful snapshot.
- No account cookies, arbitrary collector inputs, notifications or external writes are accepted.

[Working tutorial and API example](https://solidscrape-monitoring-guides.techmuhafiz.chatgpt.site/reddit-search-monitor/)

Call through the Apify API, SDKs or MCP. For support, share the run ID, query and expected output through Issues. Keep your API token private.

# Actor input Schema

## `mode` (type: `string`):

Supplied records run only this monitor. Live mode starts the fixed named collector in your account and bills its fees separately.

## `inputRecords` (type: `array`):

Optional in inputRecords mode, up to100 exported records. No collector is started in that mode.

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

Includes unchanged or filtered valid records. Live collection is capped at this count for one place or search.

## `maxSpendUsd` (type: `number`):

Reserves $0.008 plus $0.0005 per maxRecords for this monitor, then caps the separately billed live collector with the remainder. Apify’s run maximum charge by itself caps only this monitor.

## `previousSnapshot` (type: `object`):

Optional prior SNAPSHOT record from this monitor. Keep it locally or in your own workflow and pass it to the next run. Max500 retained records; absence never means deletion.

## `matchTerms` (type: `array`):

Case-insensitive substrings in title and text; a single term may contain a complete phrase. Matching occurs after collection, so filtered collector records can still cost money.

## `matchMode` (type: `string`):

all requires every term; any requires at least one; phrase requires exactly one term.

## `publishedAfter` (type: `string`):

YYYY-MM-DD or ISO timestamp with timezone. Dates mean midnight UTC, not a whole-day upper endpoint.

## `publishedBefore` (type: `string`):

Inclusive exact UTC instant. Records with unavailable dates are excluded when a date filter is used.

## `collectorCostAcknowledged` (type: `boolean`):

Required true only for live mode. Collector runs appear separately in your Apify account. Its output is a bounded sample, not guaranteed full history.

## `searchQuery` (type: `string`):

Broad source query. Use Exact text terms to enforce the separate post-collection match rule.

## `subreddit` (type: `string`):

Optional bare subreddit name. Live mode collects posts only; supplied records can include comments.

## Actor input object example

```json
{
  "mode": "live",
  "maxRecords": 10,
  "maxSpendUsd": 0.1,
  "matchMode": "all",
  "collectorCostAcknowledged": true,
  "searchQuery": "python",
  "subreddit": "python"
}
```

# Actor output Schema

## `changes` (type: `string`):

No description

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

No description

## `snapshot` (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 = {
    "collectorCostAcknowledged": true,
    "searchQuery": "python",
    "subreddit": "python"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidscrape/reddit-scraper").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 = {
    "collectorCostAcknowledged": True,
    "searchQuery": "python",
    "subreddit": "python",
}

# Run the Actor and wait for it to finish
run = client.actor("solidscrape/reddit-scraper").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 '{
  "collectorCostAcknowledged": true,
  "searchQuery": "python",
  "subreddit": "python"
}' |
apify call solidscrape/reddit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solidscrape/reddit-scraper"
        }
    }
}
```

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/SrK81OOwpRhkrJlx3/builds/169pW3a5FNpjvZAIJ/openapi.json