# Reddit Viral Radar — Trending Posts ✅ (`nexascout/reddit-viral-radar`) Actor

Find Reddit posts that stand out in their communities. Compare score and comment percentiles against same-age posts, filter approval ratios, and export ranked discussion links with coverage details.

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

## Pricing

from $650.00 / 1,000 reddit listing-page attempts

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 Viral Radar — Trending Posts

Find Reddit posts that stand out in the communities you follow. Compare each post with a sample of similarly aged posts from the same subreddit, then export ranked discussion links and metrics.

Use it for content research, community monitoring, campaign ideas and finding discussions worth reviewing.

### Quick start

1. Enter subreddit names, such as `hiking` and `camping`.
2. Choose a maximum number of results and optional score, comment or approval filters.
3. Set a spending limit. For two communities, start with an $8 maximum charge and a 480-second collection budget.
4. Run the Actor and open **Overview**. Check the run summary for coverage before treating the scan as complete.

```json
{
  "subreddits": ["hiking", "camping"],
  "maxResults": 25,
  "maxBaselinePerSubreddit": 60,
  "maxCandidatesPerSubreddit": 30,
  "minScorePercentile": 0.7,
  "maxRunSeconds": 480,
  "region": "US"
}
```

`maxResults` is a maximum, not a guaranteed count. Availability, filters, the baseline sample and your limits affect the result.

### What the scores mean

| Field | Meaning |
| --- | --- |
| `scorePercentile` | Relative score among similarly aged baseline posts in the same community |
| `commentsPercentile` | Relative comment count among that baseline |
| `resonanceScore` | Mean of the available percentiles, from 0 to 1 |
| `upvoteRatio` | Approval ratio, used as an optional independent filter |
| `confidence` | `ok`, `insufficient` or `degenerate` |
| `scoreSampleSize`, `commentSampleSize` | Available baseline observations for each metric |

The baseline comes from the community's **new** listing; candidates come from **hot**, **rising** and **top**. Comparisons use age groups: under 1 hour, 1–6 hours, 6–24 hours, 24–72 hours and over 72 hours.

Each metric needs at least 10 baseline observations with some variation. Unsupported percentiles remain `null`. Posts with insufficient baselines may still appear with raw metrics when no percentile threshold excludes them; they rank after supported scores.

A high score indicates relative community resonance at this observation. It does not establish future growth or count views. Reddit score is upvotes minus downvotes; comment count measures volume, not reply-tree depth.

### Inputs

| Input | Default | Purpose |
| --- | --- | --- |
| `subreddits` | Required | Communities, with or without `r/`; duplicates are removed |
| `maxResults` | 50 | Maximum saved posts, up to 200 |
| `maxBaselinePerSubreddit` | 120 | Baseline sample cap |
| `maxCandidatesPerSubreddit` | 60 | Candidate cap per community |
| `minScorePercentile` | 0 | Optional minimum, 0–1 |
| `minCommentsPercentile` | 0 | Optional minimum, 0–1 |
| `minUpvoteRatio` | 0 | Optional minimum approval ratio, 0–1 |
| `maxRunSeconds` | 480 | Collection budget, 30–900 seconds |
| `region` | US | Access location; it does not filter posts by author country |

The time budget starts after initialization. Startup, cleanup and an active page can extend total run time. Collection also stops when the spending limit prevents further work.

### Output and coverage

Each row includes the post ID, subreddit, author, title, absolute `postUrl`, content `url`, raw metrics, age, percentile scores, confidence, sample sizes and `observedAt`.

- **Overview:** ranked posts, strongest supported scores first.
- **Metrics:** approval, activity and sample sizes.
- **Links & authors:** original discussion/content links and identifiers.

The `OUTPUT` key-value record reports totals, applied filters, excluded counts, source outcomes, billing counters and any stopped reason. `PARTIAL` means the selected time or spending limit stopped collection; saved rows remain available. The platform can show a successful run while this summary correctly reports partial coverage.

Recognized blocks or exhausted request errors are reported. If all candidate sources are unavailable, the Actor fails clearly. A valid search with candidates excluded by filters can succeed with zero rows. Some communities can be inaccessible or have too few baseline posts.

### Pricing

| Event | Price |
| --- | ---: |
| Run start | $0.05 per started GB of memory, minimum one GB |
| Reddit listing-page attempt | $0.65 |
| Unique post saved to the run dataset | $0.02 |

At the default **2 GB**, the start fee is **$0.10**. Listing attempts include baseline, hot/rising/top pages and retries, including blocked pages or work that yields no matching posts. Browser resource files are not separate events. Results are charged once per saved dataset row; a post saved in a later run is charged again.

Examples without retries:

- One community, four listing pages and 20 saved posts: **$3.10**.
- Two communities, eight listing pages and 25 saved posts: **$5.80**.
- Four listing pages and no saved posts: **$2.70**.

These are billing examples, not promises of page coverage or result count. A short budget can stop the run before a candidate listing is read. A $1.45 maximum charge is supported for a small attempt; $8 gives more room for the two-community example. The Actor checks spending before navigation and output writes.

### API and integrations

Use Actor ID `j46hGtiSapQuIqF31` so your integration remains stable if the Store name changes:

```http
POST https://api.apify.com/v2/actors/j46hGtiSapQuIqF31/runs?maxTotalChargeUsd=8
Authorization: Bearer YOUR_APIFY_TOKEN
Content-Type: application/json
```

Send the JSON input above as the request body. Poll the returned run ID:

```http
GET https://api.apify.com/v2/actor-runs/RUN_ID
Authorization: Bearer YOUR_APIFY_TOKEN
```

Read rows from the returned default dataset and coverage from the default key-value store:

```http
GET https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json
GET https://api.apify.com/v2/key-value-stores/KEY_VALUE_STORE_ID/records/OUTPUT
Authorization: Bearer YOUR_APIFY_TOKEN
```

Schedule recurring snapshots in Apify or connect results to your automation tools and database. Compare separately stored runs if you need changes over time.

This Actor is an independent research tool and is not affiliated with Reddit.

# Actor input Schema

## `subreddits` (type: `array`):

Target subreddits (without r/ prefix).

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

Hard cap on emitted posts.

## `maxBaselinePerSubreddit` (type: `integer`):

Cap on `new`-listing posts collected for the resonance baseline.

## `maxCandidatesPerSubreddit` (type: `integer`):

Cap on hot/rising/top candidate posts collected.

## `minScorePercentile` (type: `number`):

Minimum score percentile (0-1) vs same-age baseline. 0 = no threshold.

## `minCommentsPercentile` (type: `number`):

Minimum comments percentile (0-1) vs same-age baseline. 0 = no threshold.

## `minUpvoteRatio` (type: `number`):

Minimum upvote_ratio (0-1), an approval signal. 0 = no threshold.

## `region` (type: `string`):

Proxy country for the residential proxy.

## `maxRunSeconds` (type: `integer`):

Collection budget in seconds. Startup and the active page may finish later. Saved results and coverage are reported when time or spending limits stop collection.

## Actor input object example

```json
{
  "subreddits": [
    "hiking",
    "camping"
  ],
  "maxResults": 50,
  "maxBaselinePerSubreddit": 120,
  "maxCandidatesPerSubreddit": 60,
  "minScorePercentile": 0,
  "minCommentsPercentile": 0,
  "minUpvoteRatio": 0,
  "region": "US",
  "maxRunSeconds": 480
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "subreddits": [
        "hiking",
        "camping"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/reddit-viral-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 = { "subreddits": [
        "hiking",
        "camping",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nexascout/reddit-viral-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 '{
  "subreddits": [
    "hiking",
    "camping"
  ]
}' |
apify call nexascout/reddit-viral-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexascout/reddit-viral-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/j46hGtiSapQuIqF31/builds/l7tUPk4cXPjn35ddH/openapi.json