# Reddit Subreddit Scraper — compare communities (`entrogix_works/reddit-subreddit-benchmark`) Actor

Compare subreddits side by side. One row per community: median score, comment ratio, posting rate, how concentrated attention is, ranked. Unofficial; not affiliated with Reddit.

- **URL**: https://apify.com/entrogix\_works/reddit-subreddit-benchmark.md
- **Developed by:** [Entrogix Works](https://apify.com/entrogix_works) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 subreddit benchmarkeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Subreddit Scraper — compare communities

Put several subreddits side by side and get **one row per community**, ranked by how much a typical post actually earns there.

Subscriber counts are a poor guide. A million-member subreddit where everything sinks is worse for you than a focused one where posts get read and answered. Median score per post, comment ratio, and how concentrated attention is are what separate them — and those only mean something when communities are measured the same way.

### What you get per subreddit

| Field | Example |
|---|---|
| `reachRank` | `1` |
| `subreddit`, `posts`, `postsCompared` | `webdev`, `25`, `13` |
| **`medianScore`**, `medianScoreRange` | `469`, `[227, 644]` |
| `maxScore` | `3052` |
| `medianComments` | `28` |
| **`commentsPerScore`** | `0.197` |
| **`topShare`** | `0.61` |
| **`sampleSpanDays`** | `6.7` |
| `postsPerDay` (`new` only) | `48.2` |
| `uniqueAuthors`, `medianAgeHours` | `24`, `9.4` |

**Posts are only compared against posts of a similar age.** A subreddit's hot listing mixes posts from an hour ago with hits from three weeks ago — we measured one r/webdev listing holding both a 1-point post from that morning and a 5,569-point post from three weeks earlier. Median score over that mixture is not a property of the community; it just records how many old hits happened to be on the page, and it moved by 4× between two runs minutes apart.

So score statistics are computed over posts **between 1 and 14 days old** — old enough to have collected votes, recent enough not to be a survivor. `postsCompared` tells you how many of the fetched posts qualified, and the summary reports the window it used. If you would rather see the raw listing, use **Reddit Post Scraper**, which returns every post with no windowing.

**`medianScoreRange`** is a 95% confidence interval for the median, computed from the order statistics — no distribution assumed. Reddit scores have a long tail, so a median taken from a dozen posts moves between runs: we measured the same subreddit at 289 and then 503 twenty minutes later. The interval tells you how much of that number you can lean on. Sampling more posts per subreddit narrows it.

**`reachRank`** is ordered by `medianScore`, not post count. Volume rewards busy communities; it does not tell you whether your post will be seen. A subreddit with fewer than 5 comparable posts gets `reachRank: null` rather than a rank derived from three numbers, and the summary sets `topTwoTooClose` when the first- and second-placed intervals overlap — a rank you should not act on as if it were settled.

**`commentsPerScore`** is median comments divided by median score. High values mark communities where people *reply* rather than just upvote — which is what you want if you are asking a question, and a warning if you are broadcasting.

**`topShare`** is the share of all score held by the top 10% of sampled posts. Near 1 means one thread owns the front page and new posts are invisible.

**`sampleSpanDays`** is how many days the sampled posts cover. On a `hot` sample this is your grace period: a community whose top posts span half a day buries new posts within hours, while one spanning a week keeps a good post visible.

**`postsPerDay`** is returned **only when `sort: "new"`**, and is `null` otherwise. On `hot` the sample is the posts that survived, not consecutive posts, so dividing by the time span would measure how fast the front page turns over — not how much gets posted. Rather than return a plausible number under the wrong name, this field stays empty until you sample a listing where it means what it says.

**`uniqueAuthors`** shows whether the sample comes from many people or a handful holding the surface.

### Summary (key-value store, `BENCHMARK_SUMMARY`)

`subreddits`, `subredditsWithPosts`, `medianOfMedianScore`, `strongest`, `concentrated` (communities where the top 10% holds 70% or more of all score), `notRanked` (too few comparable posts to rank), `topTwo` with `topTwoTooClose`, and `ageWindowHours` — the age window the scores were compared over.

### Input

```json
{
  "subreddits": ["programming", "webdev", "javascript"]
}
```

Names or URLs both work.

**Two or more subreddits are required.** One subreddit is not a comparison, and the run is rejected rather than returning a single row that answers nothing. If you want the post list for one community, use **Reddit Post Scraper** instead.

### Scope and limits — please read

Each community is measured on a **recent sample from one listing** (hot by default), not on its full history. That is what makes the figures comparable across communities and current rather than historical. It is not a lifetime average and should not be read as one.

Which listing you sample changes what you learn: `hot` reflects where attention is now, `new` reflects raw posting rate — and `postsPerDay` is filled in only for the latter. Compare like with like.

Subreddits that return no posts are still returned as a row with `posts: 0` and `reachRank: null`, so "private, banned, or misspelled" is distinguishable from "quiet".

Scores that cannot be read are returned as `null`, never `0`, so a missing figure cannot drag a median down.

**Posters are counted, not profiled.** Only the public `u/handle` is used, and only to count how many distinct people are posting. Profile URLs, avatars, and internal account identifiers are not collected, and there is no mode that searches a person's posting history.

### Pricing

Charged **per subreddit**, not per post. Reddit renders its listings client-side, so each community needs a full browser fetch — the price reflects that rather than the number of posts returned. Sampling more posts per subreddit therefore costs you nothing, and it narrows `medianScoreRange`.

### Disclaimer

**This is an unofficial tool and is not affiliated with, endorsed by, or sponsored by Reddit.** "Reddit" is a trademark of its respective owner and is used here only to describe what this Actor reads. You are responsible for ensuring your use of the collected data complies with applicable law and with Reddit's terms.

# Actor input Schema

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

Two or more subreddit names or URLs. One subreddit is not a comparison and is rejected.

## `sort` (type: `string`):

Which listing each subreddit is sampled from. Hot reflects current attention; new reflects raw posting rate.

## `samplePerSubreddit` (type: `integer`):

All subreddits are sampled the same way so the comparison stays fair. Scores are compared only across posts of a similar age, so a larger sample leaves more posts to compare and narrows the reported range. You are charged per subreddit, not per post, so raising this does not cost you more.

## `minIntervalMs` (type: `integer`):

Pacing between subreddit fetches. Reddit rate-limits aggressively; do not lower this.

## `useProxy` (type: `boolean`):

On by default. Reddit blocks datacenter ranges heavily.

## `proxyType` (type: `string`):

Residential is the vetted setting for this target.

## Actor input object example

```json
{
  "subreddits": [
    "programming",
    "webdev",
    "javascript"
  ],
  "sort": "hot",
  "samplePerSubreddit": 50,
  "minIntervalMs": 3000,
  "useProxy": true,
  "proxyType": "RESIDENTIAL"
}
```

# Actor output Schema

## `results` (type: `string`):

Every row this run produced, as JSON.

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

Totals and medians for this run, so you can judge the rows without reading them all.

# 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": [
        "programming",
        "webdev",
        "javascript"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("entrogix_works/reddit-subreddit-benchmark").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": [
        "programming",
        "webdev",
        "javascript",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("entrogix_works/reddit-subreddit-benchmark").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": [
    "programming",
    "webdev",
    "javascript"
  ]
}' |
apify call entrogix_works/reddit-subreddit-benchmark --silent --output-dataset

```

## MCP server setup

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

```

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/MrP110KK0T7k0Bmui/builds/hvwhjq8e6j0QLuvWR/openapi.json