# Reddit Scraper: Posts, Comments, Search & Users (`axlymxp/reddit-posts-comments-scraper`) Actor

Scrape Reddit posts, comments, subreddits and user profiles by keyword, subreddit, URL or username. No proxy needed, no API key. Buyer-intent tags on every row, monitor mode returns only new items on scheduled runs. Pay only for results.

- **URL**: https://apify.com/axlymxp/reddit-posts-comments-scraper.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** Social media, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 89.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 dataset items

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, Search & Users

Turn any Reddit keyword, subreddit, post URL or username into clean JSON rows: posts with full text and media links, flattened comment threads, subreddit stats and user profiles. It reads Reddit the way the official mobile app does, so it **needs no proxy and no API key**, and it adds two things most Reddit scrapers charge extra for or do not have:

- **Buyer-intent tags.** Every post and comment carries `intent_matches`, the list of phrases it contains from an editable keyword list ("looking for", "recommend", "alternative to", "too expensive", "hiring"…). Filter the dataset to the rows that are asking for something.
- **Monitor mode.** Turn on *Only new since last run* and a scheduled run returns only posts and comments it has not delivered before. Brand monitoring and lead alerts without duplicates.

> **Post comment threads are temporarily unavailable.** Since 24 October 2026 Reddit blocks the endpoint that returns a post's comment tree, so with *Include comments* on, posts are returned without their comments (the run still succeeds). Posts, search, subreddit feeds, post URLs, user profiles and a user's own comment history (`userContent`) work as before. This note will be removed when comment threads are back.

Built for marketers tracking brand and competitor mentions, lead-gen agencies mining "any recommendations?" threads, researchers building sentiment datasets, and AI builders feeding Reddit discussions into LLM pipelines.

### What you get

One row per item, with a `type` column so posts, comments, users and subreddits can share a dataset or be split in the Overview tabs.

#### Posts (`type: post`)

| Field | Description |
| --- | --- |
| `id`, `url` | Reddit post id and permalink |
| `title`, `text` | Title and self-text (markdown as written) |
| `subreddit`, `subreddit_subscribers` | Where it was posted and the community size |
| `author`, `author_id`, `author_flair` | Who posted it |
| `score`, `upvote_ratio`, `num_comments`, `awards` | Engagement |
| `created_at`, `edited_at` | ISO-8601 UTC timestamps |
| `flair`, `is_self`, `is_video`, `is_nsfw`, `is_spoiler`, `is_stickied`, `is_locked` | Post attributes |
| `domain`, `external_url`, `media_urls`, `thumbnail` | Linked site and media (images, galleries, Reddit video) |
| `crosspost_parent` | Original post id for crossposts |
| `intent_matches` | Intent phrases found in title + text |
| `query`, `source` | The search that found it; `search`, `subreddit`, `url` or `user` |
| `scraped_at` | When the row was collected |

#### Comments (`type: comment`)

Comment rows currently come only from a user's comment history (`usernames` with `userContent` set to `comments` or `overview`); post comment threads are temporarily unavailable (see the note at the top).

| Field | Description |
| --- | --- |
| `id`, `url` | Comment id and permalink |
| `post_id`, `post_title`, `post_url` | The thread it belongs to |
| `parent_id`, `depth` | Position in the tree (`t3_…` = top-level reply to the post, `t1_…` = reply to a comment) |
| `text` | Comment body (markdown) |
| `author`, `author_id`, `author_flair`, `is_submitter` | Who wrote it and whether they are the original poster |
| `score`, `controversiality`, `awards`, `distinguished`, `is_stickied` | Engagement and moderator flags |
| `created_at`, `edited_at` | ISO-8601 UTC |
| `intent_matches` | Intent phrases found in the body |

#### Users (`type: user`) and subreddits (`type: subreddit`)

Users: `username`, `display_name`, `bio`, `created_at`, `link_karma`, `comment_karma`, `total_karma`, `is_verified`, `is_mod`, `is_gold`, `is_employee`, `has_verified_email`, `icon_url`.
Subreddits: `name`, `title`, `description`, `sidebar`, `subscribers`, `created_at`, `is_nsfw`, `subreddit_type`, `language`, `icon_url`.

With **Enrich authors** on, posts and comments also carry `author_karma`, `author_created_at` and `author_is_verified`, so leads can be ranked by account age and activity.

### Use cases

- **Lead generation.** Search "looking for a CRM" across r/smallbusiness and r/sales, keep rows whose `intent_matches` is not empty, enrich authors, and hand the list to outreach.
- **Brand and competitor monitoring.** Schedule a daily run on your brand names with monitor mode on and a webhook to Slack; each run delivers only the new threads.
- **Market and product research.** Pull the top threads of the year from a subreddit with all comments and read what people complain about before building.
- **Sentiment and AI datasets.** Export thousands of posts and threaded comments with timestamps and scores as training or evaluation data.
- **Community analytics.** Track subscriber and active-user counts of competing subreddits, or profile the most active contributors of a niche.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQueries` | array | – | Keywords or phrases. Reddit operators work (`title:`, `selftext:`, `author:`, `flair:`, `site:`, `AND`, `OR`, `NOT`, quotes). |
| `subreddits` | array | – | With queries: search inside these subreddits. Without: scrape their feeds. |
| `startUrls` | array | – | Post, subreddit or user URLs. |
| `usernames` | array | – | Users to profile; `userContent` picks profile only, posts, comments or both. |
| `searchSort` | enum | `relevance` | `relevance`, `hot`, `top`, `new`, `comments` |
| `listingSort` | enum | `new` | `new`, `hot`, `top`, `rising`, `controversial` |
| `timeFilter` | enum | `month` | `hour`, `day`, `week`, `month`, `year`, `all` |
| `postedAfter`, `postedBefore` | date | – | UTC date filter on posts, e.g. `2026-09-01`. |
| `includeComments` | boolean | `false` | Add the comment tree of every post as `comment` rows. **Temporarily unavailable:** posts are returned without comments. |
| `maxCommentsPerPost` | integer | `50` | Cap per post; collapsed threads are expanded as needed. |
| `commentSort` | enum | `confidence` | `confidence` (best), `top`, `new`, `controversial`, `old`, `qa` |
| `intentKeywords` | array | 29 phrases | Edit or clear the intent list. |
| `enrichAuthors` | boolean | `false` | Author karma, account age and verification on every row. |
| `onlyNewSinceLastRun` | boolean | `false` | Monitor mode: skip ids delivered by earlier runs with the same input. |
| `includeNsfw` | boolean | `false` | Keep over-18 posts. |
| `maxPostsPerSource` | integer | `100` | Posts per search, feed or user (Reddit serves at most about 1,000 per listing). |
| `maxItems` | integer | `500` | Total rows for the run. |
| `proxyConfiguration` | object | off | Optional Apify Proxy. Without it the actor runs at Reddit's limit of 100 calls per 10 minutes per IP and waits when the limit is reached; with it, it rotates IPs instead. |

#### Example input

```json
{
  "searchQueries": ["web scraping tool recommendation"],
  "subreddits": ["webscraping", "dataengineering"],
  "timeFilter": "month",
  "maxPostsPerSource": 10,
  "maxItems": 100
}
```

#### Example output

```json
{
  "type": "post",
  "id": "1nq7o2x",
  "url": "https://www.reddit.com/r/webscraping/comments/1nq7o2x/looking_for_a_tool_that_handles_cloudflare/",
  "title": "Looking for a tool that handles Cloudflare",
  "text": "We scrape about 50 retail sites and half of them moved behind Cloudflare this year...",
  "subreddit": "webscraping",
  "subreddit_subscribers": 103806,
  "author": "data_pipeline_dan",
  "score": 41,
  "upvote_ratio": 0.93,
  "num_comments": 27,
  "created_at": "2026-09-26T14:03:11Z",
  "flair": "Getting started",
  "is_self": true,
  "is_nsfw": false,
  "media_urls": [],
  "intent_matches": ["looking for"],
  "query": "web scraping tool recommendation",
  "source": "search",
  "scraped_at": "2026-10-04T09:12:44Z"
}
```

### How many rows and how fast

Reddit answers 100 API calls per 10 minutes per IP. One call returns up to 100 posts; a post's comments cost one call plus one per 100 collapsed replies. Without a proxy a run of 1,000 posts takes under a minute; 100 posts with 50 comments each takes about 15 to 30 minutes because the actor waits for the window to reset. Enable Apify Proxy for runs that need thousands of comment threads: the actor switches to a fresh IP instead of waiting. Reddit itself serves at most about 1,000 items per listing or search; use narrower queries, subreddits or time filters to reach further back.

### Scheduling and integrations

Schedule the actor in Apify (hourly, daily, weekly), turn on monitor mode, and attach a webhook or an integration (Slack, Google Sheets, Make, Zapier, n8n) to the run's dataset. Each run delivers only new items. The dataset can be downloaded as JSON, CSV, Excel or XML, or read through the Apify API.

### Use with AI assistants

The actor can be called from any agent framework through the Apify API or the Apify MCP server. Ask the assistant to "search Reddit for people asking for alternatives to <product> in the last week and summarise the complaints"; the rows come back as structured JSON with `intent_matches` already set, so the model spends its tokens on the content rather than on parsing.

### FAQ

**Do I need Reddit API credentials or a proxy?** No. The actor uses the same anonymous access path as Reddit's mobile app. A proxy is optional and only speeds up very large runs.

**Why fewer rows than I asked for?** Reddit caps every listing and search at about 1,000 items, filters drop more, and private, quarantined or deleted content is skipped. You pay only for rows actually stored.

**Are comments complete?** Post comment threads are temporarily unavailable because Reddit blocks that endpoint (see the note at the top). When they are available, the actor flattens the full tree and expands collapsed "load more" stubs up to `maxCommentsPerPost`. Very long threads are cut at that cap in the order of `commentSort`.

**How do date filters behave?** `postedAfter` / `postedBefore` are applied to every post the run sees. Reddit's search returns at most a few hundred items per query, so for a date window use `searchSort: top` or `relevance` with a matching `timeFilter`, or scrape the subreddit feed with `listingSort: new`, which stops paging once it passes `postedAfter`. A loose query sorted by `new` returns only the newest few hundred posts.

**Can I get only new posts each day?** Yes. Keep the input identical, enable `onlyNewSinceLastRun`, and schedule the run. The memory is tied to the input; change the input and it starts fresh.

**Is the data public?** Everything returned is public Reddit content and public profile data. No login-only, private or deleted content is accessed. Respect Reddit's terms and local law when you use the data.

**What happens when something fails?** Unavailable subreddits, deleted posts or suspended users are logged and skipped; the run continues with the rest and reports what it did in the status message.

# Actor input Schema

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

Keywords or phrases to search for. Reddit search operators work: `title:`, `selftext:`, `author:`, `flair:`, `site:`, `AND`, `OR`, `NOT`, quotes. One search per query (and per subreddit when subreddits are set).

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

Subreddit names such as `webscraping` or `r/webscraping`. With search queries: the searches run inside these subreddits. Without queries: the subreddit feed is scraped (see Listing sort).

## `startUrls` (type: `array`):

Reddit URLs: a post (`/r/<sub>/comments/<id>/...`) returns the post and, if enabled, its comments; a subreddit URL (`/r/<sub>/` or `/r/<sub>/top/`) returns its feed; a user URL (`/user/<name>/`) returns the profile and content.

## `usernames` (type: `array`):

Reddit usernames such as `spez` or `u/spez`: the profile plus their recent posts and comments (see User content).

## `searchSort` (type: `string`):

Order of search results.

## `listingSort` (type: `string`):

Order of a subreddit feed (used when subreddits are given without search queries, or for subreddit URLs).

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

Time window for search and for `top` / `controversial` feeds.

## `postedAfter` (type: `string`):

Keep only posts created on or after this UTC date, e.g. `2026-09-01`. Comments are not date-filtered.

## `postedBefore` (type: `string`):

Keep only posts created on or before this UTC date, e.g. `2026-09-30`.

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

Fetch the comment tree of every post. Each comment is its own row (`type: comment`) with `post_id`, `parent_id` and `depth`.

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

Cap on comments stored per post (all depths, flattened). Larger values expand collapsed threads with extra API calls.

## `commentSort` (type: `string`):

Which comments come first when a post has more than the cap.

## `intentKeywords` (type: `array`):

Phrases that mark a buyer, seeker or complaint. Every post and comment gets an `intent_matches` list of the phrases it contains (case-insensitive, whole words). Clear the list to disable.

## `enrichAuthors` (type: `boolean`):

Add `author_karma`, `author_created_at` and `author_is_verified` to every post and comment (one extra API call per distinct author, up to 300 per run). Useful for ranking leads by account age and activity.

## `onlyNewSinceLastRun` (type: `boolean`):

Remember the ids emitted by earlier runs with the same input and skip them, so a scheduled run returns only new posts and comments. Changing the input starts a fresh memory.

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

Keep posts marked over-18.

## `userContent` (type: `string`):

What to fetch for each username: profile only, or the profile plus recent posts and/or comments.

## `maxPostsPerSource` (type: `integer`):

Posts taken from each search, subreddit feed or user. Reddit serves at most about 1,000 per listing.

## `maxItems` (type: `integer`):

Hard cap on dataset rows for the run: posts, comments, users and subreddits together. You pay per row stored.

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

Optional. The actor works without a proxy at Reddit's limit of 100 API calls per 10 minutes per IP (it waits when the limit is hit). Enable Apify Proxy for large runs: the actor rotates to a fresh IP instead of waiting.

## Actor input object example

```json
{
  "searchQueries": [
    "web scraping tool recommendation"
  ],
  "subreddits": [
    "webscraping",
    "dataengineering"
  ],
  "startUrls": [],
  "usernames": [],
  "searchSort": "relevance",
  "listingSort": "new",
  "timeFilter": "month",
  "includeComments": false,
  "maxCommentsPerPost": 50,
  "commentSort": "confidence",
  "intentKeywords": [
    "looking for",
    "recommend",
    "recommendation",
    "alternative to",
    "alternatives to",
    "best tool",
    "best way to",
    "any suggestions",
    "suggestions?",
    "how do i",
    "how do you",
    "what do you use",
    "is there a",
    "is there any",
    "worth it",
    "pricing",
    "too expensive",
    "switch from",
    "switching from",
    "need help",
    "anyone know",
    "does anyone",
    "hire",
    "hiring",
    "freelancer",
    "for hire",
    "frustrated",
    "hate that",
    "wish there was"
  ],
  "enrichAuthors": false,
  "onlyNewSinceLastRun": false,
  "includeNsfw": false,
  "userContent": "overview",
  "maxPostsPerSource": 100,
  "maxItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQueries": [
        "web scraping tool recommendation"
    ],
    "subreddits": [
        "webscraping",
        "dataengineering"
    ],
    "startUrls": [],
    "usernames": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/reddit-posts-comments-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 = {
    "searchQueries": ["web scraping tool recommendation"],
    "subreddits": [
        "webscraping",
        "dataengineering",
    ],
    "startUrls": [],
    "usernames": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/reddit-posts-comments-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 '{
  "searchQueries": [
    "web scraping tool recommendation"
  ],
  "subreddits": [
    "webscraping",
    "dataengineering"
  ],
  "startUrls": [],
  "usernames": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axlymxp/reddit-posts-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axlymxp/reddit-posts-comments-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/yIEBOpfc6M9PAvoLw/builds/GUZb41o1kWx875aGv/openapi.json