# Reddit Communities Scraper - Subreddit Search, No Login (`dami_studio/reddit-communities-scraper`) Actor

Search Reddit communities by topic or name and get one row per subreddit: name, title, public description, link, id, creation date, icon and creator. Look up names you already have with exact-name mode. No account or API key. No member counts: Reddit's public search does not publish them.

- **URL**: https://apify.com/dami_studio/reddit-communities-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Social media, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 communities

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Communities Scraper: find subreddits by topic or name, no account needed

Give it topics or community names. You get one row per subreddit that Reddit's own community search returns for each
term: the name, title, public description, link, id, creation date and icon.

What you will not get is a member count or an adult flag. Reddit's public community search does not publish either, so
the rows do not carry them.

| | |
|---|---|
| **Input** | Topics, community names, `r/` names or reddit.com/r/ links, up to 50 per run |
| **Output** | One row per community |
| **Ceiling** | About 250 communities per search term, where Reddit's own search stops |
| **Account needed** | None from you |
| **Price** | $0.93 per 1,000 communities, flat on every plan |

### 🔍 What Reddit Communities Scraper does

Each search term goes to Reddit's subreddit search on its own. The communities come back in Reddit's order until the
term runs out or your limit is reached, and `rank` keeps that order on every row.

Two terms often find the same community. It is delivered once, under the first term that found it, so one run never
charges you twice for the same subreddit.

Switch on `exactNameOnly` and it stops being a search and becomes a lookup. Give it the names you already have and you
get back the one community per name whose name matches exactly, with its id, title, description and creation date. A
name that does not come back on the first page of Reddit's results gets a free `NOT_FOUND` note instead.

### 📥 What you give it

```json
{
  "queries": ["home espresso", "r/gardening", "https://www.reddit.com/r/AskHistorians/"],
  "maxCommunitiesPerQuery": 100,
  "exactNameOnly": false,
  "includeNsfw": false
}
```

| Field | Default | What it is |
|---|---|---|
| `queries` | none | Topics or community names, one per line. `r/name` and reddit.com/r/ links are read as the name. Up to 50 per run, and repeats are searched once. |
| `maxCommunitiesPerQuery` | `50` | The most communities per search term, 1 to 250. It is also your spend cap per term. |
| `exactNameOnly` | `false` | Return only the community whose name is exactly the term. |
| `includeNsfw` | `false` | Mix adult (18+) communities into the results. See `nsfw` below. |
| `proxyConfiguration` | off | Leave it as it is. It exists for people who send requests through their own servers, given as http:// or https:// addresses. |

`queries` is the only field you need. Start a run with no terms and you get one free example row instead of a search.

### 📤 What you get back

A real row from a run on the term `gardening`, exactly as the actor wrote it:

```json
{
  "name": "GardeningUK",
  "title": "Gardening subreddit for the UK",
  "description": "GardeningUK is a subreddit for the discussion of gardens, gardening, tips, advice and successes with other gardeners here in the UK. Visit the Wiki for tips on where to buy seeds and what information to include when asking for advice.",
  "url": "https://www.reddit.com/r/GardeningUK/",
  "communityId": "t5_31s8w",
  "createdAt": "2014-05-15T16:24:31.000Z",
  "iconUrl": "https://b.thumbs.redditmedia.com/GqWu88Abb2ZB30Ng.jpg",
  "createdBy": "richards182",
  "nsfw": false,
  "query": "gardening",
  "rank": 3,
  "exactMatch": false,
  "scrapedAt": "2026-10-03T04:39:13.501Z"
}
```

| Field | What it is |
|---|---|
| `name` | The community's name as Reddit writes it, without `r/` |
| `title` | The title its moderators set |
| `description` | The public description as plain text, or `null` when the community has none |
| `url` | The community's page on reddit.com |
| `communityId` | Reddit's own id for it, `t5_` and a code |
| `createdAt` | When the community was created |
| `iconUrl` | Its icon when one is set, otherwise `null` |
| `createdBy` | The username Reddit lists as the community's creator, or `null` when it lists none |
| `nsfw` | `false` on a normal run. `null` when adult communities are included, because the search does not say which ones they are |
| `query` | The search term that found it |
| `rank` | Its position in Reddit's results for that term, from 1 |
| `exactMatch` | `true` when the name is exactly your term, ignoring case and spaces |
| `scrapedAt` | When the row was written |

How full the fields are, counted on 506 communities from three test runs: `title` and `createdAt` on every row,
`description` on 96%, `createdBy` on 76% and `iconUrl` on 33%. Icons thin out the further down the results you go.

### 🧾 Reading the output

Three kinds of row can land in the dataset, and only the first kind is charged.

| Row | How to spot it | Charged |
|---|---|---|
| A community | no `_sample` and no `_diagnostic` field | yes |
| The free example | `_sample: true`, only when the run had no search term | no |
| A note | `_diagnostic: true`, with an `errorCode`, an `error` in plain words and usually the `query` | no |

To keep only communities, drop every row that has `_sample` or `_diagnostic`. The example row carries a `communityId`
and a `rank` just like a real one, so filtering on those keeps it.

| Code | What it means |
|---|---|
| `NO_RESULTS` | Reddit's search found no community for this term |
| `NOT_FOUND` | With `exactNameOnly` on, no community with exactly this name came back |
| `NO_NEW_RESULTS` | Everything this term found was already delivered for an earlier term in the same run |
| `PARTIAL_RESULTS` | Reddit stopped answering partway through this term. What came before was delivered |
| `SEARCH_UNAVAILABLE` | Reddit did not answer this term. Nothing was charged for it, so run it again later |
| `UNEXPECTED_ANSWER` | Reddit answered with results for a different search, so that page was not delivered |
| `TIME_LIMIT` | The run reached its timeout before this term was read |
| `COST_LIMIT` | The maximum cost set for the run does not cover a single community |
| `BAD_INPUT` | The input could not be used. `details` says what to change |
| `UNEXPECTED_ERROR` | Something broke on our side. Please report it |

### ▶️ How to run it

1. Open [Reddit Communities Scraper](https://apify.com/dami_studio/reddit-communities-scraper) and click **Try for
   free**.
2. Type your topics or community names into **Search terms**, one per line.
3. Set **Communities per search term**. 50 is a good first look, 250 is the most.
4. Optional: switch on **Exact names only** to look up names you already have, or **Include adult (18+)
   communities**.
5. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it from the API.

### 💰 How much does it cost?

**$0.93 per 1,000 communities.** Flat on every Apify plan, no volume tiers.

You pay per community delivered. The example row and every note row are free, a community that two of your terms both
found is charged once, and a term that finds nothing adds nothing to the bill. The number of terms times
`maxCommunitiesPerQuery` is the most a run can deliver, so it is also the most it can charge for.

### 💡 What people use it for

- Finding every place a niche talks, from the big subreddit down to the small regional ones, before deciding where to
  post or what to read.
- Building the list of subreddits to watch. Run this first, then hand the names to a post or comment scraper.
- Turning a spreadsheet of community names into ids, titles, descriptions and creation dates with `exactNameOnly`.
- Spotting young communities in a topic by sorting the rows on `createdAt`.

### 🚧 What it does not do

- **No member counts, online counts or adult flags.** Reddit's public community search does not publish them, and the
  rows do not guess.
- **Reddit decides what matches.** You get what its subreddit search returns for the term, in its order. A community
  that never uses your word in its name, title or description may not show up.
- **About 250 communities per term at most.** That is where Reddit's own search stops, even for a word as broad as
  `music` (243 in a test run). Narrow terms run out after a few dozen.
- **No posts, rules, moderators or wiki pages.** This lists communities. For what gets posted in them, use the scraper
  linked below.
- **Only what a visitor who is not signed in can see.** Communities Reddit keeps out of its public search are not
  found.
- **No memory between runs.** The same terms tomorrow return, and charge for, the same communities again.

### 🧭 Which Reddit scraper do you need?

| If you want | Use |
|---|---|
| Subreddits about a topic, or details for names you already have | This one |
| Everything posted in a subreddit or by one user | [Reddit Scraper](https://apify.com/dami_studio/reddit-scraper) |
| Posts matching a keyword | [Reddit Search Scraper](https://apify.com/dami_studio/reddit-search-scraper) |
| Reddit videos as one MP4 with the sound | [Reddit Video Scraper](https://apify.com/dami_studio/reddit-video-scraper) |
| Post text cleaned up for narration | [Reddit Text Cleaner](https://apify.com/dami_studio/reddit-text-cleaner) |

### ❓ Questions people ask

**Do I need a Reddit account or an API key?** No. There is nothing to sign in to and nothing to paste.

**Why is there no member count?** Reddit's public community search does not include one, and the rows never make one
up. If member counts are the point of your job, this is the wrong tool for that part of it.

**Can I check a list of subreddit names I already have?** Yes. Put the names in **Search terms** and switch on **Exact
names only**. Each name gives one row, or a free `NOT_FOUND` note when Reddit's search does not return it.

**Are adult communities included?** Only if you switch on **Include adult (18+) communities**. They are then mixed into
the results, and because the search does not mark them, every row says `nsfw: null`.

**Why did a term return fewer communities than I asked for?** Reddit had no more for it. Its search stops at about 250
for any term, and narrow topics stop after a few dozen: `GardeningUK` gave 28 and `home espresso` 43 in a test run.

**Is scraping Reddit legal?** This reads public community listings only, never private messages or accounts. A row can
still name a person, the community's creator, and GDPR and similar laws cover that, so have a reason for keeping it.
Apify's write-up on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a sensible
starting point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Send the search terms you used and the run ID, and the log fills in the
rest.

# Actor input Schema

## `queries` (type: `array`):

Topics or community names, one per line: <code>gardening</code>, <code>home espresso</code>, <code>r/AskHistorians</code> or a reddit.com/r/... link. Up to 50 per run. Repeats are searched once.

## `maxCommunitiesPerQuery` (type: `integer`):

The most communities to return for each search term, from 1 to 250. Reddit's own search stops at about 250 for any term, and narrow topics run out sooner. Left empty, it is 50.

## `exactNameOnly` (type: `boolean`):

Return only the community whose name is exactly the search term, so <code>gardening</code> gives r/gardening and nothing else. Handy for looking up a list of communities you already know.

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

Off: Reddit leaves adult communities out of the search, and every row says <code>nsfw: false</code>. On: they are mixed in, and because Reddit's search does not mark which ones they are, every row says <code>nsfw: null</code>.

## `proxyConfiguration` (type: `object`):

Optional. Leave it as it is unless you want the requests to go through your own proxy servers, in which case list their http:// or https:// addresses here.

## Actor input object example

```json
{
  "queries": [
    "gardening"
  ],
  "maxCommunitiesPerQuery": 50,
  "exactNameOnly": false,
  "includeNsfw": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every row in the default dataset: name, title, description, url, communityId, createdAt, iconUrl, createdBy, nsfw, query, rank, exactMatch, scrapedAt. A run with no search term returns one free example row marked \_sample; a search that finds nothing or cannot be read returns one free row marked \_diagnostic with an errorCode.

# 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 = {
    "queries": [
        "gardening"
    ],
    "maxCommunitiesPerQuery": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/reddit-communities-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 = {
    "queries": ["gardening"],
    "maxCommunitiesPerQuery": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/reddit-communities-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 '{
  "queries": [
    "gardening"
  ],
  "maxCommunitiesPerQuery": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dami_studio/reddit-communities-scraper --silent --output-dataset

```

## MCP server setup

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