# 👽 Reddit Scraper - Posts, Comments & Subreddits (`renzomacar/reddit-scraper`) Actor

Scrape Reddit posts and comments from any subreddit or thread: no login, no API key. Posts with title, author, score, upvote ratio and flair; comments with their own upvote score, depth and parent, so a thread can be rebuilt as a tree. Keyword filter included. Pay per result.

- **URL**: https://apify.com/renzomacar/reddit-scraper.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Social media, AI, Developer tools
- **Features:** Limited permissions
- **Stats:** 334 total users, 7 monthly users, 93.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 Sentiment Scraper - Posts, Comments & Sentiment Data

### Reddit sentiment scraper: extract posts, comments and community insights from any subreddit

Turn Reddit into a structured dataset. This scraper collects posts and comments from subreddits, search results, and individual threads -- delivering titles, authors, upvote scores, comment text, timestamps, and flair data in a clean, export-ready format.

Reddit is one of the richest sources of authentic consumer opinion on the internet. Whether you are running market research, building a sentiment analysis pipeline, scouting content ideas, or monitoring brand mentions, this actor gives you programmatic access to the conversations that matter -- without API key management. Runs through Apify residential proxies, which Reddit requires.

> **Search availability (November 2026).** Reddit has been asking for sign-in on its
> public search feed, and this Actor does not sign in. While that lasts, a search
> query returns nothing, and the run says so in its log and status message.
> Subreddit listings and post URLs are not affected.
>
> **To follow a brand or topic meanwhile, use the keyword filter:** list the subreddits
> where it is discussed, add your words to `keywords`, and the run saves (and charges)
> only the posts that mention them.

### What data can you extract?

> **Status, 12 November 2026.** Reddit is currently refusing the pages this Actor reads vote
> counts and full comment threads from. Until that changes, runs still deliver every post with
> its title, author, date and link (and the text of self posts), but `score` and `upvoteRatio`
> come back `null`, `commentCount` comes back `0`, and `flair`, `domain` and `postType` are
> empty. Comments are limited to 100 per post, without `score`, `depth` or `parentId`. The run
> log says when this happened. While this note is here it takes precedence over the field
> descriptions, limits and examples below. It will be removed when the data is back.

> **Field availability, stated up front.** `score`, `upvoteRatio` and `commentCount`
> are populated for **subreddit posts** and are `null` for **search results**.
> **Comments carry their own `score`**, plus `depth` and `parentId`, so a thread can be
> rebuilt as a tree. `null` means "Reddit did not publish it", not "zero". Post `body` is filled for self/text posts; link posts have no body by
> definition. This Actor requires Apify **residential proxies**: Reddit refuses
> datacenter IPs on every public endpoint.

#### Post data

| Field | Type | Description |
|-------|------|-------------|
| `dataType` | string | Record type identifier (`post`) |
| `redditId` | string | Reddit fullname, e.g. `t3_1vrszc5` |
| `postTitle` | string | Title of the Reddit post |
| `author` | string | Username of the post author |
| `subreddit` | string | Subreddit where the post was published |
| `score` | integer | null | Net upvote score. `null` for search results (Reddit's search feed omits it) |
| `upvoteRatio` | number | null | Share of votes that are upvotes, 0-1. `null` for search results |
| `commentCount` | integer | null | Total comments on the post. `null` for search results |
| `body` | string | Self-text of the post. Empty for link posts, which have none |
| `url` | string | Link URL (external link posts) or post permalink |
| `postUrl` | string | Direct Reddit permalink to the post |
| `createdUtc` | string | UTC timestamp of when the post was created |
| `flair` | string | Post flair or tag |
| `postType` | string | `text`, `link`, `image`, `video`, ... |
| `domain` | string | Domain of the linked article, for link posts |
| `isStickied` | boolean | Whether the post is pinned by moderators |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was collected |

#### Comment data

| Field | Type | Description |
|-------|------|-------------|
| `dataType` | string | Record type identifier (`comment`) |
| `redditId` | string | Reddit fullname, e.g. `t1_p4fu45x` |
| `author` | string | Username of the comment author |
| `body` | string | Full text of the comment |
| `score` | integer | null | Net upvote score of the comment. `null` when Reddit hides it, on a deleted comment, or when the thread page could not be read and the run fell back to the comment feed (the log says so) |
| `depth` | integer | Nesting level (0 = top-level comment, 1 = reply to it, etc.) |
| `parentId` | string | `redditId` of the comment this one replies to. Empty for top-level comments |
| `url` | string | Link to the comment itself |
| `subreddit` | string | Subreddit of the thread |
| `createdUtc` | string | UTC timestamp of when the comment was posted |
| `postTitle` | string | Title of the parent post |
| `postUrl` | string | Permalink to the parent post |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was collected |

Comments come in the order Reddit shows the thread sorted by top: each top-level comment followed by the replies shown under it. Up to 500 per post. Reply chains that Reddit folds behind "more replies" are not opened, and a link to a single comment returns that conversation from the comment feed, without votes.

### Use cases

- **Market research** -- Understand what real users say about your product, your competitors, or your industry by mining relevant subreddits and search queries.
- **Sentiment analysis** -- Feed Reddit post and comment data into NLP pipelines to measure community sentiment around brands, product launches, or events.
- **Content ideation** -- Discover what questions people ask, what problems they face, and what topics generate the most engagement in your niche.
- **Competitive intelligence** -- Monitor competitor mentions across Reddit to track public perception and identify strengths or weaknesses in their offering.
- **Academic research** -- Collect structured datasets of online discussions for social science, linguistics, or communication studies.

### Scraping a subreddit without the Reddit API

No API key, no app registration, no OAuth flow and no rate quota to budget around. You pass subreddit names and the Actor reads what a browser sees.

That matters beyond the setup time. Reddit's API applies per-app rate limits and requires an approved application, which is a real obstacle for a one-off market study or a client project you will run twice. Here the only limits are the ones you set: `maxPostsPerSubreddit`, and `sortBy` / `timeFilter` to choose the window.

`sortBy: "top"` with `timeFilter: "year"` gives you the community's greatest hits — the reference threads people link back to. `sortBy: "new"` gives you what is happening right now. Different questions, one run each.

### Exporting posts and comments to CSV

Every row is flat, so the dataset opens straight in Excel, Sheets or a pandas dataframe with no unnesting.

`includeComments: false` returns one row per post — the shape you want for a spreadsheet. Turn it on and each comment becomes its own row alongside the posts, with `dataType` telling you which is which and `depth` showing how deep in the thread a comment sits. Filter on `dataType` after export and one run gives you both tables.

Fields that fill on essentially every post: `postTitle`, `subreddit`, `author`, `body`, `url`, `commentCount` and `createdUtc`. `score` and `upvoteRatio` come back for the large majority; Reddit hides them on a small share of threads, and the Actor leaves them null rather than guessing.

### Finding customer pain points for market research

The research move is not reading a subreddit — it is sorting it. Two columns do most of the work.

`commentCount` finds the arguments. A post with a modest `score` and a high `commentCount` is a topic people disagree about, and disagreement is where the unmet needs are. A high score with few comments is usually applause: pleasant, not informative.

`upvoteRatio` finds the tension. A ratio near 1.0 is consensus. A ratio around 0.6 means the community is split, which is exactly where a product opportunity or a positioning risk lives.

Sort by `commentCount` descending, read the top twenty `body` fields, and you have the vocabulary your customers actually use — which is worth more to a landing page than any keyword tool.

### Monitoring a subreddit for product feedback

Pass the subreddits where your customers talk, sort by `new`, and schedule the run. When Reddit's search feed is answering (see the search availability note above), `searchQueries` with your brand, your competitors, or the problem you solve widens that to all of Reddit.

Because `createdUtc` and `redditId` come back on every row, deduplicating against your last run is a one-line join: anything with an id you have not seen is new. That turns a scheduled run into a feedback stream rather than a repeated dump.

For a monitoring setup, `sortBy: "new"` with a short `timeFilter` keeps runs small and cheap. Watch `commentCount` on rows that mention you — a mention gathering replies needs a human answer today, not in next week's report.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `subreddits` | array | No | `[]` | Subreddit names, e.g., "technology", "programming". `r/technology` and a full subreddit link work too |
| `keywords` | array | No | `[]` | Keep only subreddit posts whose title or text mentions one of these words or phrases. Only matching posts (and their comments, when comments are on) are saved and charged; each post carries `matchedKeywords` |
| `searchQueries` | array | No | `[]` | Keywords to search across all of Reddit. See the search availability note above |
| `postUrls` | array | No | `[]` | Links to Reddit posts to scrape comments from. Tracking parameters and links to a single comment are accepted |
| `maxPostsPerSubreddit` | integer | No | `100` | Maximum posts to read per subreddit (1--500). With `keywords`, this is how many posts are checked |
| `includeComments` | boolean | No | `false` | Whether to extract comments from each post |
| `maxCommentsPerPost` | integer | No | `100` | Maximum comments to extract per post (1--500) |
| `includeVoteData` | boolean | No | `true` | Fetch score, upvote ratio and comment count for subreddit posts. Costs extra residential bandwidth; turn off for cheaper, faster runs when you only need titles, authors, dates and text |
| `sortBy` | string | No | `"hot"` | How to sort posts: `hot`, `new`, `top`, or `rising` |
| `timeFilter` | string | No | `"week"` | Time period when sorting by top: `hour`, `day`, `week`, `month`, `year`, `all` |
| `maxConcurrency` | integer | No | `3` | Number of browser pages to run in parallel (1--10) |

At least one subreddit, search query, or post URL must be provided.

### Example output

```json
{
    "dataType": "post",
    "postTitle": "What's the best programming language to learn in 2026?",
    "author": "dev_user123",
    "subreddit": "programming",
    "score": 1547,
    "commentCount": 342,
    "body": "I've been thinking about switching careers into software development. I have some experience with Python from college, but I'm wondering what the job market actually wants right now. Any advice?",
    "url": "https://old.reddit.com/r/programming/comments/abc123/whats_the_best_programming_language/",
    "postUrl": "https://old.reddit.com/r/programming/comments/abc123/whats_the_best_programming_language/",
    "createdUtc": "2026-02-28T15:30:00Z",
    "flair": "Discussion",
    "isStickied": false,
    "scrapedAt": "2026-03-01T12:00:00.000Z"
}
```

```json
{
    "dataType": "comment",
    "author": "senior_eng_42",
    "body": "Honestly, it depends on what you want to do. For web development, JavaScript/TypeScript is still king. For data science and ML, Python is non-negotiable. For enterprise backend work, Java and Go are in very high demand.",
    "score": 892,
    "depth": 0,
    "parentId": "",
    "url": "https://www.reddit.com/r/programming/comments/abc123/comment/def456/",
    "createdUtc": "2026-02-28T16:15:00Z",
    "postTitle": "What's the best programming language to learn in 2026?",
    "postUrl": "https://old.reddit.com/r/programming/comments/abc123/whats_the_best_programming_language/",
    "scrapedAt": "2026-03-01T12:00:00.000Z"
}
```

### How much does it cost?

This actor uses a pay-per-event pricing model. You are charged a small start fee per run plus a fee for each data record (post or comment) that is successfully extracted. Current rates are shown on the Pricing tab of the Actor page.

There are no monthly subscriptions or minimum commitments. You only pay for the data you extract.

### Tips and tricks

- **Use search queries for broad research.** Subreddit scraping is best for focused communities. To look for a brand or topic across all of Reddit there is the `searchQueries` input, which depends on Reddit's public search feed (see the search availability note above).
- **Enable comments selectively.** Comments multiply the number of results quickly. If you only need post-level data (titles, scores, dates), leave `includeComments` set to `false` to keep costs low and runs fast.
- **Sort by "top" for high-signal data.** When researching popular opinions or frequently recommended products, sort by `top` with a time filter of `month` or `year` to surface the most upvoted content.
- **NSFW subreddits are supported.** The scraper handles Reddit's age verification prompts automatically, so you can scrape any publicly accessible subreddit.

### FAQ

**How do I scrape Reddit posts and comments from a subreddit?**
Enter one or more subreddit names, choose a sort order (`hot`, `new`, `top`, or `rising`), set how many posts you want, and optionally enable comments. The scraper returns titles, authors, upvote scores, body text, timestamps, and flair as a clean dataset you can export to JSON, CSV, or Excel.

**Do I need an API key or Reddit account to use this Reddit scraper?**
No. There is no Reddit API key, OAuth app, or login to manage. You just provide subreddits, search queries, or post URLs and the actor returns the public data directly.

**Why use this instead of the official Reddit API?**
The official Reddit API now has strict rate limits, paid access tiers, and approval requirements that make large-scale or commercial scraping painful. This actor needs no API credentials, has no per-app rate-limit ceiling to manage, and lets you scrape posts plus their comment threads across many subreddits in one run.

**What is a good Reddit API alternative for sentiment analysis?**
This actor is a practical Reddit API alternative for sentiment and market research: it pulls posts and comment text (with upvote scores and depth) ready to feed straight into NLP or LLM pipelines, without the cost and quota headaches of the official API.

**Can I use this for sentiment analysis and brand monitoring?**
Yes. Scrape the subreddits where the brand, product, or topic is discussed (and add `searchQueries` when Reddit's search feed is answering, see the note above), enable comments, and feed the post and comment text into your sentiment model. Sort by `top` with a `month` or `year` time filter to surface the highest-signal opinions.

**Is scraping public Reddit data legal?**
This tool collects only publicly accessible posts and comments. You are responsible for complying with Reddit's terms, applicable laws such as GDPR and CCPA, and using the data ethically. Avoid collecting personal data without a lawful basis.

### Automate it

Add this Reddit scraper to an Apify **Schedule** to monitor a subreddit or a set of threads automatically every day or week — ideal for ongoing sentiment tracking and competitive intelligence. Connect the output to **Make, n8n, Zapier, Google Sheets, Slack, or a webhook** through Apify integrations so new posts and comments flow straight into your dashboards, alerts, or NLP pipeline. Recurring runs keep your sentiment dataset continuously fresh.

### Related actors

- [YouTube Channel & Video Scraper](https://apify.com/renzomacar/youtube-scraper) -- Extract YouTube channel statistics and video metadata to combine with Reddit community insights for a complete content research workflow.
- [TikTok Profile & Post Scraper](https://apify.com/renzomacar/tiktok-scraper) -- Collect TikTok creator profiles and video data to complement Reddit sentiment analysis with social media performance metrics.
- [Instagram Scraper](https://apify.com/renzomacar/instagram-scraper) -- Add Instagram profile and post data to your social listening so brand sentiment spans Reddit and Instagram.
- [Telegram Channel Scraper](https://apify.com/renzomacar/telegram-channel-scraper) -- Capture public Telegram channel messages and views to widen your sentiment and OSINT coverage beyond Reddit.
- [Trustpilot Reviews Scraper](https://apify.com/renzomacar/trustpilot-reviews) -- Combine Reddit opinions with structured Trustpilot reviews for a fuller picture of customer sentiment.

# Actor input Schema

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

Subreddit names to scrape, e.g. 'technology', 'programming'. 'r/technology' and a full subreddit link also work.

## `keywords` (type: `array`):

Optional. Keep only the posts from the subreddits above whose title or text mentions at least one of these words or phrases (whole words, any letter case). Every post read counts towards "Max posts per subreddit", but only the matching posts are saved and charged (plus their comments, when comments are switched on). Each saved post lists the keywords it matched. Works with Reddit's public listings, so it is not affected by the search sign-in issue.

## `searchQueries` (type: `array`):

Search Reddit for keywords. Reddit has been asking for sign-in on its public search feed (November 2026); while that lasts a search query returns nothing and the run reports it. When search answers, score and upvoteRatio are null for its results, because Reddit does not publish vote counts there.

## `postUrls` (type: `array`):

Links to Reddit posts to scrape comments from. Tracking parameters and links to a single comment are accepted.

## `maxPostsPerSubreddit` (type: `integer`):

Maximum number of posts to read per subreddit. With a keyword filter this is how many posts are checked; only the matching ones are saved.

## `sortBy` (type: `string`):

How to sort posts in the subreddit listing.

## `timeFilter` (type: `string`):

Time period filter when sorting by top.

## `includeVoteData` (type: `boolean`):

Fetch upvote score, upvote ratio and comment count for subreddit posts. This needs extra requests through residential proxies, so turning it off makes runs noticeably cheaper and faster when you only need titles, authors, dates and post text.

## `includeComments` (type: `boolean`):

Also extract the comments of each post, with their upvote score, their depth in the thread and the comment they reply to.

## `maxCommentsPerPost` (type: `integer`):

Maximum number of comments to extract per post (up to 500), in the order Reddit shows the thread sorted by top: each top-level comment followed by its replies.

## Actor input object example

```json
{
  "subreddits": [
    "technology",
    "programming"
  ],
  "maxPostsPerSubreddit": 100,
  "sortBy": "hot",
  "timeFilter": "week",
  "includeVoteData": true,
  "includeComments": false,
  "maxCommentsPerPost": 100
}
```

# Actor output Schema

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

One row per post or comment.

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

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

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

```

## MCP server setup

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