# Reddit Scraper - Scrape Posts, Comments & Search, No API Key (`s-r/reddit-scraper`) Actor

Reddit web scraper for public subreddits, post threads and search results. Scrape Reddit posts and comments without an API key, login or OAuth app: title, author, score, comment count, timestamp, flair and reply depth as JSON, CSV or Excel.

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

## Pricing

from $0.50 / 1,000 run start fees

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 Scraper: posts, comments and search without an API key

This Reddit scraper collects public posts and visible comments as structured dataset rows, without a Reddit API key, a login or an OAuth app. Choose a subreddit listing, a single post with its discussion, or a keyword search. Each post or comment becomes one row, with a `type` field identifying which kind it is. Public permalinks let you return to the original discussion, while Reddit identifiers help you match the same post across repeated collections.

Use the actor for community monitoring, research into product feedback, or a collection of discussions for analysis. A subreddit run answers what a community is discussing in a selected order. Search finds posts mentioning a phrase across Reddit or within one community. Post mode adds the visible comments beneath a specific post, keeping the author, text, score and reply relationships that Reddit makes available.

### What the Reddit scraper returns

- **Three modes from one actor**: a subreddit listing, a single post with its visible comment tree, and a search across Reddit or inside one subreddit.
- **Score, comment count, author, subreddit and timestamp** on every post, plus the public permalink and Reddit's own identifiers.
- **Comment depth and parent identifiers**, so the reply tree can be rebuilt rather than read as a flat list.
- **`score_hidden` as its own field.** Reddit hides comment scores for a while after posting; a null score with `score_hidden: true` is a real state, not a missing value.
- **Post flags for analysis**: NSFW, spoiler, original content, crosspost count, flair, and whether a row is a promoted post rather than an organic one.
- **Pagination that follows Reddit's own next links**, so a large run walks through the listing instead of fetching the first page again.
- **Clean exports**: download the dataset as JSON, CSV, Excel or XML, or read it through the Apify API.

### Reddit scraper input

Set `mode` to `subreddit`, `post` or `search`. Subreddit mode needs `subreddit`. You can provide the community name with or without `r/`. Post mode needs `post_url`, either a full Reddit link or a relative post path. Search mode needs `query`; adding `subreddit` restricts the search to that community. Quoted phrases are accepted using Reddit's own search syntax.

| Field | Type | Required | Default | What it does |
|---|---|---|---|---|
| `mode` | select | yes | `subreddit` | `subreddit`, `post` or `search` |
| `subreddit` | string | conditional | – (prefill `webscraping`) | Required in subreddit mode; optional in search mode to restrict the search |
| `post_url` | string | conditional | – | Required in post mode. Any Reddit post link, or a relative post path |
| `query` | string | conditional | – | Required in search mode |
| `sort` | select | no | `hot` | Listings: `hot`, `new`, `top`, `rising`, `controversial`. Search: `relevance`, `hot`, `top`, `new`, `comments` |
| `time` | select | no | `all` | `all`, `hour`, `day`, `week`, `month`, `year` |
| `limit` | integer | no | `50` | Maximum rows, 1 to 1000 |
| `proxy_country` | string | no | – | Optional two-letter country code |
| `retries` | integer | no | `4` | Attempts per page, 1 to 6 |

The default `sort` is `hot` in both listing and search mode. Listings support `hot`, `new`, `top`, `rising` and `controversial`. Search supports `relevance`, `hot`, `top`, `new` and `comments`. When a listing sort is supplied to search that search does not support, the search uses `new`. The `time` field defaults to `all` and accepts `hour`, `day`, `week`, `month` and `year`. It applies to listing sorts `top` and `controversial`, and to search.

`limit` is the maximum number of dataset rows, from 1 to 1000, with a default of 50. In post mode the post and its comments share this limit. A limit of 10 therefore allows the post and up to nine visible comments. `retries` accepts one to six attempts per page and defaults to four. The optional `proxy_country` field accepts a two-letter country code. Leaving it empty uses the configured country.

The store's initial example requests 50 posts from `webscraping`, sorted by `hot`, with the all-time window. That community name is a prefill, rather than a default added to every API request. An API request in subreddit mode must still supply a community name.

A search inside one community looks like this:

```json
{
  "mode": "search",
  "query": "price tracking",
  "subreddit": "webscraping",
  "sort": "new",
  "time": "month",
  "limit": 100
}
```

### Output

This is a real post row collected from the Python community during the local verification on 2 October 2026:

```json
{
  "type": "post",
  "id": "t3_g53lxf",
  "title": "Lad wrote a Python script to download Alexa voice recordings, he didn't expect this email.",
  "url": "https://www.reddit.com/r/Python/comments/g53lxf/lad_wrote_a_python_script_to_download_alexa_voice/",
  "link_url": "https://i.redd.it/2s0dj8ob12u41.png",
  "author": "iEslam",
  "subreddit": "Python",
  "score": 12343,
  "comments_count": 133,
  "created_at": "2020-04-20T23:11:39Z",
  "domain": "i.redd.it",
  "rank": 1,
  "is_nsfw": false,
  "is_promoted": false,
  "is_spoiler": false,
  "is_original_content": false,
  "crossposts": 6,
  "selftext": null,
  "flair": "Discussion",
  "author_fullname": "t2_g532u",
  "position": 1,
  "_type": "post",
  "source": "reddit-scraper",
  "platform": "reddit",
  "fetched_at": "2026-10-02T10:07:17.035Z",
  "short_id": "g53lxf",
  "post_url": "https://www.reddit.com/r/Python/comments/g53lxf/lad_wrote_a_python_script_to_download_alexa_voice/",
  "post_id": "g53lxf",
  "text": "Lad wrote a Python script to download Alexa voice recordings, he didn't expect this email.",
  "author_handle": "iEslam",
  "author_id": "t2_g532u",
  "posted_at": "2020-04-20T23:11:39Z",
  "likes": 12343
}
```

And a real comment row from post mode, collected on the same day from a thread in the n8n community. It is a reply at depth 2, so it carries the identifier of the comment it answers:

```json
{
  "type": "comment",
  "id": "t1_o82m6zk",
  "post_id": "t3_1rgczas",
  "author": "PulsePilot-AI",
  "score": 2,
  "score_hidden": false,
  "text": "Mostly lead gen. I’ve also used it for finding trending topics, getting weekly news updates (pulling Reddit posts from a few of my favorite communities, having an llm summarize and send an update directly to my email). Hbu what have ur main uses cases been?",
  "url": "https://www.reddit.com/r/n8n/comments/1rgczas/free_reddit_scraper_no_api_key_needed_free_n8n/o82m6zk/",
  "depth": 2,
  "subreddit": "n8n",
  "author_fullname": "t2_1n95wnqzrk",
  "post_short_id": "1rgczas",
  "parent_comment_short_id": "o7rmltz",
  "post_url": "https://www.reddit.com/r/n8n/comments/1rgczas/free_reddit_scraper_no_api_key_needed_free_n8n/",
  "created_at": "2026-03-01T16:12:55Z",
  "_type": "comment",
  "source": "reddit-scraper",
  "platform": "reddit",
  "fetched_at": "2026-10-02T10:07:27.227Z",
  "short_id": "o82m6zk",
  "comment_id": "o82m6zk",
  "comment_url": "https://www.reddit.com/r/n8n/comments/1rgczas/free_reddit_scraper_no_api_key_needed_free_n8n/o82m6zk/",
  "parent_comment_id": "o7rmltz",
  "author_handle": "PulsePilot-AI",
  "author_id": "t2_1n95wnqzrk",
  "posted_at": "2026-03-01T16:12:55Z",
  "likes": 2
}
```

Listing rows contain the title, author, subreddit, score, comment count, submission timestamp and public URL. They also include a destination link, domain, listing rank, post flags, crosspost count and any visible flair. `position` gives the order within the returned collection. A self post's full body is generally absent from a listing; use post mode when you need its visible body text.

Search results retain their search-specific fields. They include title, author, subreddit, score, comment count, timestamp, flair and a visible text excerpt. They do not promise the listing-only flags, domain or rank. Submission timestamps remain strings; the search representation can include a UTC offset where the listing representation uses `Z`.

Comment rows carry `text`, `depth`, `post_id`, `score` and `score_hidden`. A null score represents an unavailable score, rather than an invented zero. Additional parent identifiers describe reply relationships. A parent comment may have been deleted, so its identifier can remain referenced even when that parent has no dataset row. `post_id` on comments retains Reddit's fullname representation; `post_short_id` supplies the matching post identifier without its prefix.

All rows include `fetched_at`, `source`, `platform`, `short_id` and `_type`. These extra fields support joining and comparing collections while the original fields remain available. The default key-value store provides a `summary` record, including counts and mode-specific information. An `errors` record is present when a collection encountered an actual input or upstream error.

### Use cases

**Brand and product monitoring.** Search mode with your brand or product name, sorted by `new`, on a schedule. Because `created_at` and `score` come back as real values, you can tell a post quietly sitting at two upvotes from one that is climbing, which is the difference between noise and something you should answer today.

**Datasets for AI and NLP.** Subreddit mode with a high limit gives you posts with their titles and links; post mode gives you the visible discussion under any of them with the reply depth intact. `selftext` and `text` are plain text with the markup stripped, which is what an embedding or summarisation pipeline wants.

**Tracking a community's agenda.** Run `top` with `time: week` on a schedule and store the results. Which topics reach the top of a community, and at what score, is a trend signal that is hard to get anywhere else.

**Competitor and sentiment research.** Reddit is where people say what they think of tools they pay for. Search inside the subreddits where your category lives, keep the rows with `score` above a threshold, and you have a filtered feed of opinions that carried weight with other readers.

**Lead and problem discovery.** Search for phrases such as "looking for a tool" or "how do I" in the communities your customers read, and review the newest matches with their permalinks.

### How this Reddit scraper compares

| | This actor | Reddit's official Data API | Open-source scripts |
|---|---|---|---|
| Setup | Fill in a form or send JSON | Register an app, OAuth credentials, accept the Data API terms | Install, configure, maintain your own code |
| Login or API key | **None** | Required | Usually an API key |
| Posts, comments and search | **One input, three modes** | Separate endpoints | Depends on the library |
| Hidden score kept apart from a missing one | **Yes, `score_hidden`** | Yes | Rarely |
| Export | **JSON, CSV, Excel, XML, API** | JSON only | Whatever you build |
| Cost | $3.50 per 1,000 rows, pay per event | Free tier with strict rate limits; commercial use priced separately | Your own servers and time |

Other Reddit actors in the Apify Store mostly focus on one job each, for example listings only or comments only. This one covers subreddit listings, single threads and search with one schema, so rows from different runs can be joined on `id`, `short_id` and `post_id`.

### Pricing

The live model has two events. `run_start` costs $0.0005 once per run, including an empty run or invalid input. `item` costs $0.0035 for each post or comment actually delivered. This is $3.50 per 1000 rows plus the start fee, so a 1,000-row run costs $3.5005. Empty collections have no item charges. Posts and comments share the same per-row price, and duplicate posts across collected pages are delivered and charged only once. All pricing is pay-per-event: there are no compute-unit charges on top.

Users without a paid Apify plan receive at most ten rows per run. The input limit is reduced before collection, and item charges follow the rows delivered. Paying users keep their requested limit. The summary reports the delivered count and whether the free-plan cap was reached.

### Limits and collection behavior

Reddit decides how many posts or comments are available. Asking for 1000 rows does not guarantee 1000 results; a listing may end sooner. Listings and searches follow Reddit's continuation links. A request interrupted by the collection budget resumes automatically within the actor's remaining run time. If collection cannot finish, already collected rows remain available and the summary identifies the partial result.

Post mode reads the discussion rendered on the post page. It does not expand “load more comments” controls. The post's `comments_count` therefore describes Reddit's total, while `commentsFound` describes comments found on the returned page. These two counts can differ. Empty searches and unavailable communities finish successfully with no dataset rows. Invalid input or a temporary upstream block also produces an empty, successful run with an explanation.

Private, quarantined and banned subreddits return nothing, which is correct rather than an error: anything that requires a logged-in account is out of reach by design, since there is no credential in the input.

### FAQ

#### Does Reddit Scraper need my Reddit login?

No. It collects public data without a customer login, API key or OAuth token. Private or unavailable content is outside this collection.

#### Is this a Reddit API alternative?

For reading public data, yes. You do not register an app or manage OAuth tokens; you send the input and get rows back. If you need to post, vote or read private messages, you still need Reddit's own API, because this actor only reads public pages.

#### Can I search only one subreddit?

Yes. Set `mode` to `search`, provide `query`, and add `subreddit`. Omit `subreddit` to search across Reddit. The returned subreddit field identifies the community for each result.

#### Can I scrape all the comments on a post?

You get the comment tree Reddit renders on the post page, with depth and parent identifiers, which is the top of the discussion. Replies hidden behind "load more comments" are not expanded.

#### Why are fewer rows returned than I requested?

`limit` is a ceiling. A listing can end, a query can have fewer matches, and a post can render fewer comments than its total comment count. Partial collection is reported explicitly when a requested continuation cannot finish.

#### Are empty results charged per item?

No. Item charges correspond to delivered posts and comments. The separate $0.0005 start event still applies once to an empty run, matching the existing pricing model.

#### Can I use it from Python, n8n or Make?

Yes. Call the actor through the Apify API or one of Apify's integrations, then read the default dataset. Post rows share their core fields (`id`, `title`, `author`, `subreddit`, `score`, `url`, `created_at`) across modes, so a workflow built on a subreddit run can read a search run too.

# Actor input Schema

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

Subreddit returns a listing of posts. Post returns one post plus its comment tree. Search returns results for a query, optionally inside one subreddit.

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

Subreddit name without the r/ prefix. Required in subreddit mode. In search mode it is optional and restricts the search to that community instead of all of Reddit.

## `post_url` (type: `string`):

Full Reddit post URL. Required in post mode. Any of Reddit's URL forms works and every returned link is normalised to www.reddit.com.

## `query` (type: `string`):

What to search for. Required in search mode. Reddit's own search syntax works, including quoted phrases.

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

How to order the results. Hot, new, top, rising and controversial apply to a subreddit listing. Search additionally accepts relevance and most-comments.

## `time` (type: `string`):

Only applies to the Top and Controversial sorts, and to search.

## `limit` (type: `integer`):

How many rows to return, 1 to 1000. A listing page carries 25 posts and the walk follows Reddit's own next cursor.

## `proxy_country` (type: `string`):

Two-letter country code for the exit, for example us or nl. Leave empty to let the proxy choose.

## `retries` (type: `integer`):

Attempts per page. Collection stops when the shared request budget is exhausted.

## Actor input object example

```json
{
  "mode": "subreddit",
  "subreddit": "webscraping",
  "post_url": "https://www.reddit.com/r/n8n/comments/1rgczas/free_reddit_scraper_no_api_key_needed_free_n8n/",
  "query": "web scraping",
  "sort": "hot",
  "time": "all",
  "limit": 50,
  "proxy_country": "us",
  "retries": 4
}
```

# Actor output Schema

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

One row per post or comment.

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

Mode, pages fetched and rows returned.

## `errors` (type: `string`):

Failures with a code and a redacted message.

# 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 = {
    "mode": "subreddit",
    "subreddit": "webscraping",
    "sort": "hot",
    "time": "all",
    "limit": 50,
    "retries": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {
    "mode": "subreddit",
    "subreddit": "webscraping",
    "sort": "hot",
    "time": "all",
    "limit": 50,
    "retries": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "mode": "subreddit",
  "subreddit": "webscraping",
  "sort": "hot",
  "time": "all",
  "limit": 50,
  "retries": 4
}' |
apify call s-r/reddit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/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/rx8si9EwgPo8cr81T/builds/BnC8pSggsAez8GG4J/openapi.json
