# Reddit Subreddit Finder & Ranker (`apt_marble/reddit-subreddit-finder-ranker`) Actor

Give it a topic and get back the Reddit communities worth posting in, ranked by how alive they actually are: posts per day, median score and engagement per member — not just subscriber counts. Find the 40k-member community where you get seen instead of the 4M one where you sink. No account needed.

- **URL**: https://apify.com/apt\_marble/reddit-subreddit-finder-ranker.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ranked subreddits

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 Finder & Ranker

Give it a topic and it hands back the communities worth posting in — ranked by
how alive they actually are, not by how many people once clicked "join". For
every topic it merges three independent discovery sources, deduplicates the
results, filters out user profiles, private communities and anything outside
your size window, then samples each survivor's recent posts to measure real
posting cadence, median score, median comments and **engagement per
subscriber**. That last number is what separates the 40,000-member community
where your post gets read from the 4,000,000-member one where it sinks in
eleven minutes. Built for marketers, community managers, founders, researchers
and anyone tired of guessing which subreddit is the right one.

### What you can do with it

- **Find where your audience already is.** Feed in your product category and get
  a ranked list of the communities discussing it, including the niche ones that
  never show up in Reddit's own search box.
- **Avoid the graveyards.** Subscriber counts include everyone who ever joined,
  including people who left Reddit in 2016. Posts per day and median comments
  tell you whether anyone is still home.
- **Pick the community where you will actually be seen.** The opportunity score
  ranks by engagement per subscriber, so under-saturated communities rise to the
  top instead of the giants everyone already posts in.
- **Build a Reddit posting calendar.** Export the shortlist, sort by activity
  level, and plan which community gets which piece of content.
- **Size up a niche before you enter it.** Total members, total daily
  engagement and author diversity across every community for a topic tell you
  how big and how concentrated the conversation really is.
- **Research competitors' territory.** Search their product name as a topic and
  see every community where it comes up.

### What you get

One row per subreddit. Abridged real example:

```json
{
  "rank": 1,
  "name": "homeassistant",
  "title": "Home Assistant",
  "url": "https://www.reddit.com/r/homeassistant/",
  "subscribers": 574660,
  "description": "Open source home automation that puts local control and privacy first. Powered by a worldwide community of tinkerers and DIY enthusiasts.",
  "createdAt": "2015-12-19T13:02:23.000Z",
  "subredditType": "public",
  "over18": false,
  "language": "en",
  "submissionType": "any",
  "allowsImages": true,
  "allowsPolls": true,
  "matchedTopics": ["home automation"],
  "matchedTopicCount": 1,
  "discoveredVia": ["subreddit-search", "autocomplete", "post-search"],
  "sourceCount": 3,
  "activityAnalyzed": true,
  "sampleSize": 50,
  "sampleOldestPostAt": "2026-07-28T04:39:57.000Z",
  "sampleNewestPostAt": "2026-07-28T20:56:40.000Z",
  "sampleSpanHours": 16.28,
  "newestPostAgeHours": 0.05,
  "postsPerDay": 72.242,
  "engagementSampleSize": 30,
  "engagementIsProvisional": false,
  "medianScore": 2,
  "medianComments": 4.5,
  "averageScore": 28.43,
  "commentsPerPost": 24,
  "distinctAuthors": 49,
  "authorDiversity": 0.98,
  "activityLevel": "very-high",
  "engagementPerPost": 11,
  "dailyEngagement": 794.66,
  "engagementPer1kSubscribers": 1.3828,
  "opportunityScore": 13.97,
  "scrapedAt": "2026-07-28T20:59:42.015Z"
}
```

That is a real row: r/homeassistant was returned by all three discovery sources
for the topic "home automation", posts 72 times a day, and outranks the
4.5-million-member r/homeautomation because its audience is far more engaged
per member.

### Input reference

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `topics` | list of text | — (required) | The topics, niches, products or keywords to find communities for, one per line. Plain phrases work best: `home automation`, `indie game marketing`, `mechanical keyboards`. Each topic is searched separately and the results are merged. |
| `minSubscribers` | number | `1000` | Skip communities smaller than this. Filters out abandoned and one-person communities while keeping genuinely niche ones. |
| `maxSubscribers` | number | none | Skip communities larger than this. Use it to deliberately avoid the huge default subreddits. |
| `includeNsfw` | true/false | `false` | Keep adult and quarantined communities in the results. |
| `maxSubredditsPerTopic` | number | `50` | How many communities to keep per topic after filtering. The strongest matches are kept: found by several sources, ranked highly by Reddit's own relevance order. Maximum 500. |
| `analyzeActivity` | true/false | `true` | Read a sample of each community's recent posts to compute cadence, medians and the opportunity score. Turn off for a faster, cheaper discovery-only run. |
| `activitySampleSize` | number | `50` | How many recent posts to read per community. 10–500. |
| `maxConcurrency` | number | `5` | How many communities to work on at once. 1–20. |
| `country` | select | `us` | Which country's view of Reddit to use. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `rank` | number | Position in the final ranking, 1 = best opportunity. |
| `name` | text | Subreddit name, without the `r/`. |
| `title` | text | The community's own headline. |
| `url` | link | Direct link to the subreddit. |
| `subscribers` | number | Total members. |
| `description` | text | The community's public description. |
| `createdAt` | date | When the community was created. |
| `subredditType` | text | `public` or `restricted`. |
| `over18` / `quarantined` | true/false | Adult and quarantine flags. Empty on the rare row whose community flag could not be read — never guessed as `false`. |
| `language`, `category` | text | Community language and Reddit's own category. |
| `icon`, `banner` | link | Community artwork. |
| `submissionType` | text | What can be posted: `any`, `self` or `link`. |
| `allowsImages`, `allowsVideos`, `allowsPolls`, `wikiEnabled` | true/false | Community features. |
| `matchedTopics` | list | Which of your topics found this community. |
| `matchedTopicCount` | number | How many of your topics it matched. |
| `discoveredVia` | list | Which discovery sources returned it. |
| `sourceCount` | number | How many of the three sources agreed — a relevance signal in itself. |
| `activityAnalyzed` | true/false | Whether a post sample was measured for this row. |
| `sampleSize` | number | How many recent posts were measured. |
| `sampleOldestPostAt`, `sampleNewestPostAt` | date | The window the sample covers. |
| `sampleSpanHours` | number | How many hours that window spans. |
| `newestPostAgeHours` | number | How long ago the most recent post appeared. |
| `postsPerDay` | number | Real posting cadence measured across the sample. |
| `engagementSampleSize` | number | How many posts the score and comment medians were counted from — the settled posts, or the whole sample when too few of them had settled (see below). |
| `engagementIsProvisional` | true/false | True when the community posts so fast that fewer than three of its sampled posts have settled. The medians then cover the whole sample and are a floor rather than a settled figure. |
| `medianScore` | number | Median upvote score across the counted posts. |
| `medianComments` | number | Median comment count across the counted posts. |
| `averageScore` | number | Mean score — compare with the median to spot outlier-driven communities. |
| `commentsPerPost` | number | Mean comments per post. |
| `distinctAuthors` | number | How many different people posted in the sample. |
| `authorDiversity` | number | Distinct authors ÷ sample size. Low means a handful of people carry the community. |
| `activityLevel` | text | `very-high`, `high`, `moderate`, `low`, `dormant`, or `unknown` when the sample was too thin to measure a cadence. |
| `engagementPerPost` | number | Median score plus twice the median comments. |
| `dailyEngagement` | number | Engagement per post × posts per day. |
| `engagementPer1kSubscribers` | number | Daily engagement per 1,000 members — the raw signal behind the score. |
| `opportunityScore` | number | 0–100. Engagement per subscriber on a logarithmic curve. High = an active audience that is not yet saturated. |
| `scrapedAt` | date | When the row was produced. |

Rows are ordered by `opportunityScore`, highest first, with ties broken by
member count. If you would rather rank by raw reach, sort by `subscribers` —
both numbers are in every row.

**How activity is measured.** The sample is read from the community's most
recent posts. Posting cadence uses every post in it, but score and comment
medians deliberately ignore posts less than six hours old: a post that went up
four minutes ago has a score of 1 no matter how good the community is, and the
busier the community the younger its newest posts are — scoring those would
punish a community for being active. `engagementSampleSize` tells you how many
posts actually counted. In the rare case where fewer than three of them have
settled, the medians fall back to the whole sample and `engagementIsProvisional`
is set so you know to read them as a floor. Pinned announcements are left out of
both the cadence and the medians — they sit at the top of a community forever
and would distort each.

### Pricing

Pay per event, so you pay for results rather than for runtime.

| What you pay for | Price | Effective rate |
| --- | --- | --- |
| **Ranked subreddit** — one row written to your dataset | $0.001 | $1.00 per 1,000 communities |
| **`subreddit-activity-analysis`** — one community measured for cadence, medians and the opportunity score | $0.002 | $0.002 per community measured |

Communities filtered out by your subscriber range or NSFW setting are never
charged, and duplicates across topics are merged into one row before anything is
billed. The activity charge only applies to communities that were actually
measured: turn `analyzeActivity` off and it never applies at all, and a
community that could not be measured is not charged for it.

### FAQ

**Do I need a Reddit account?**
No. You do not need a Reddit account, a login, or any credentials — just enter
what you want and run it.

**What does it cover?**
Everything Reddit shows the public. Communities that are private or banned are
not included.

**How fast is it?**
Results come back in large batches, so big jobs finish in minutes rather than
hours. A typical run — three topics, 50 communities each, activity measured — is
a few minutes end to end. Raise `maxConcurrency` to go faster.

**How many communities will one topic return?**
Up to `maxSubredditsPerTopic` (50 by default, 500 maximum) after filtering.
Broad topics comfortably fill that; very narrow ones return fewer, which is
itself useful information.

**Why is a community with fewer members ranked above a bigger one?**
That is the point. The ranking is engagement per subscriber, so a busy 30,000
member community outranks a sleepy 3,000,000 member one. Sort by `subscribers`
if you want the reach ranking instead.

**Can I run it on a schedule?**
Yes. Communities and their activity shift over time, so a monthly or quarterly
run keeps your shortlist current. Each run returns the full current picture —
there is no state carried between runs.

**Does it return NSFW communities?**
Only if you switch `includeNsfw` on. Adult and quarantined communities are
excluded by default, and so is the occasional community whose adult flag could
not be read at all — an unknown is never treated as safe.

# Actor input Schema

## `topics` (type: `array`):

The topics, niches, products or keywords you want to find communities for. One per line. Plain phrases work best — "home automation", "indie game marketing", "mechanical keyboards". Each topic is searched separately and the results are merged and deduplicated.

## `minSubscribers` (type: `integer`):

Skip communities smaller than this. The default of 1,000 filters out abandoned and single-person communities while keeping genuinely niche ones.

## `maxSubscribers` (type: `integer`):

Skip communities larger than this. Useful for deliberately avoiding the huge default subreddits where a new post disappears in minutes. Leave empty for no upper limit.

## `includeNsfw` (type: `boolean`):

Turn on to keep adult and quarantined communities in the results. Off by default.

## `maxSubredditsPerTopic` (type: `integer`):

How many communities to keep for each topic after filtering. The strongest matches are kept first — a community found by several discovery sources and ranked highly by Reddit's own relevance ordering wins.

## `analyzeActivity` (type: `boolean`):

Read a sample of each community's most recent posts to work out posts per day, median score, median comments and the opportunity score. Turn off for a faster, cheaper run that returns discovery results and subscriber counts only.

## `activitySampleSize` (type: `integer`):

How many recent posts to read per community when measuring activity. 50 is enough for a stable median in most communities; raise it for very busy ones, lower it for a cheaper run.

## `maxConcurrency` (type: `integer`):

How many communities to work on at the same time. Higher finishes sooner; lower is gentler and steadier.

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

Which country's view of Reddit to use. Reddit content is the same almost everywhere, so the default suits nearly every run.

## Actor input object example

```json
{
  "topics": [
    "home automation",
    "indie game marketing",
    "python"
  ],
  "minSubscribers": 1000,
  "maxSubscribers": 500000,
  "includeNsfw": false,
  "maxSubredditsPerTopic": 50,
  "analyzeActivity": true,
  "activitySampleSize": 50,
  "maxConcurrency": 5,
  "country": "us"
}
```

# Actor output Schema

## `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 = {
    "topics": [
        "home automation",
        "mechanical keyboards"
    ],
    "minSubscribers": 1000,
    "includeNsfw": false,
    "maxSubredditsPerTopic": 50,
    "analyzeActivity": true,
    "activitySampleSize": 50,
    "maxConcurrency": 5,
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/reddit-subreddit-finder-ranker").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 = {
    "topics": [
        "home automation",
        "mechanical keyboards",
    ],
    "minSubscribers": 1000,
    "includeNsfw": False,
    "maxSubredditsPerTopic": 50,
    "analyzeActivity": True,
    "activitySampleSize": 50,
    "maxConcurrency": 5,
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/reddit-subreddit-finder-ranker").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 '{
  "topics": [
    "home automation",
    "mechanical keyboards"
  ],
  "minSubscribers": 1000,
  "includeNsfw": false,
  "maxSubredditsPerTopic": 50,
  "analyzeActivity": true,
  "activitySampleSize": 50,
  "maxConcurrency": 5,
  "country": "us"
}' |
apify call apt_marble/reddit-subreddit-finder-ranker --silent --output-dataset

```

## MCP server setup

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

```

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/la30Rk9YaZuxwU4pi/builds/90UgECsiounLmZzB1/openapi.json