# Reddit Scraper - Posts, Comments, Subreddits, Users & Search (`neverempty/reddit-thread-extractor`) Actor

For brand monitoring, market research, lead discovery and AI datasets: Reddit posts, comments, subreddits, user profiles and keyword search as table rows with text, author, score, date, flair and media links. No login or API key. Long runs finish with every row kept. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/neverempty/reddit-thread-extractor.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Social media, Marketing, AI
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.30 / 1,000 result returneds

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 Scraper - Posts, Comments, Subreddits, Users & Search

Scrape Reddit posts, comments, subreddits, user profiles and keyword search results, and export them to CSV, Excel or JSON with no Reddit account and no API key. Built for brand monitoring, market research, lead discovery, sentiment analysis and AI or RAG datasets.

Paste subreddit, post, user or search URLs (or just type subreddit names and keywords) and get every post with its title, text, author, score, upvote ratio, comment count, flair, link and date, plus the top comments of each post with author, score, depth and date. Every row also names the input it came from in `source`, so you always know which subreddit or search it belongs to.

**Built to finish.** Long runs end as Succeeded with every row collected so far: the Actor wraps up shortly before the run's time limit and adds a free row naming any input it did not finish.

### What you can scrape

- **Subreddits** - posts sorted by Hot, New, Top (hour to all time) or Rising, with page after page of results, plus one row with the subreddit's title, description, icon, banner image, weekly visitors and weekly contributions.
- **Posts and comments** - full post text (plain and HTML), link, images, video links, flair, score, upvote ratio and comment count, and the comments with author, score, depth, parent, reply count, date and HTML.
- **Keyword search** - posts, comments, communities, users or media (image and video posts) that match your words, across all of Reddit or inside one subreddit, sorted by relevance, hot, top, new or most comments.
- **User profiles** - karma (total, post and comment), account date, avatar and description, plus the user's posts and comments.
- **Exact date ranges and flair filters** - posts and comments between two dates, and only posts that carry a flair.

### Who uses it

- **Brand and competitor monitoring** - posts and comments that mention your product, on a schedule with Sort = New.
- **Market and product research** - real customer questions and complaints from the communities where your buyers talk.
- **Lead discovery** - people asking for a tool or service like yours in niche subreddits, with their usernames.
- **Sentiment analysis and AI datasets** - post and comment text (plain and HTML) with scores and dates, ready for a spreadsheet, a model or a RAG pipeline.

### How to use

1. Add one or more **Reddit URLs** (subreddit, post, user or search page), or fill **Subreddits**, **Users** or **Search terms**.
2. Choose **Sort**, **Time range** and how many posts and comments you want.
3. Run, then download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.

Example input:

```json
{
  "startUrls": [{ "url": "https://www.reddit.com/r/technology/" }],
  "searches": ["best crm for startups"],
  "sort": "top",
  "time": "week",
  "maxPostsPerSource": 25,
  "includeComments": true,
  "maxCommentsPerPost": 10
}
```

| Field | What it does |
|---|---|
| `startUrls` | Subreddit (`/r/name/`, `/r/name/top/?t=week`, a flair view such as `/r/name/?f=flair_name:"Showcase"`, `/r/popular/`, `/r/all/`), post (`/r/name/comments/id/...`), user (`/user/name/`) or search (`/search/?q=...`) URLs |
| `subreddits`, `usernames`, `searches` | The same without building URLs (names in any letter case, e.g. `python` for r/Python) |
| `searchPosts`, `searchComments`, `searchCommunities`, `searchUsers`, `searchMedia` | What a search returns (posts by default; also comments, communities, users, or image and video posts) |
| `searchCommunityName` | Search inside one subreddit (user search always covers all of Reddit) |
| `sort`, `time` | Hot / New / Top / Rising for subreddits; Relevance / Hot / Top / New / Comments for search; time range for Top and search |
| `maxItems`, `maxPostsPerSource`, `maxCommentsPerPost` | How much to collect |
| `includeComments` | Open each post for its full text and top comments (on by default) |
| `includeCommunityInfo`, `includeUserPosts`, `includeUserComments` | Extra rows for subreddits and users |
| `postDateLimit`, `commentDateLimit` | Only posts or comments since a date |
| `postedBefore`, `commentedBefore` | Only posts or comments until a date (a plain date covers the whole day in UTC) |
| `onlyWithFlair` | Only posts that have a post flair |
| `includeNSFW` | Keep or drop posts marked NSFW |

Coming from another Reddit scraper? The field names `maxPostCount`, `maxComments`, `skipComments`, `skipUserPosts`, `skipCommunity`, `ignoreStartUrls`, `maxCommunitiesCount` and `maxUserCount` work here too. A field the Actor does not know, or a setting that would have no effect (such as Sort = Rising for a search), stops the run with a free row that names it, so you never pay for rows you did not ask for.

### Output

Every row has `dataType` (`post`, `comment`, `community`, `user`) so one table holds everything, and `source` tells you which input it came from.

```json
{
  "dataType": "post",
  "id": "t3_1abc234",
  "parsedId": "1abc234",
  "url": "https://www.reddit.com/r/example/comments/1abc234/how_do_you_track_your_coffee_recipes/",
  "title": "How do you track your coffee recipes?",
  "body": "I keep losing my notes on grind size and ratio. What do you use?",
  "html": "<p>I keep losing my notes on grind size and ratio. What do you use?</p>",
  "postType": "text",
  "flair": "Question",
  "author": "example_user",
  "communityName": "example",
  "createdAt": "2026-10-15T07:14:20.292Z",
  "upVotes": 66,
  "upVoteRatio": 0.93,
  "numberOfComments": 16,
  "imageUrls": [],
  "videoUrls": [],
  "isAd": false,
  "source": "https://www.reddit.com/r/example/",
  "sourceType": "community",
  "scrapedAt": "2026-10-15T09:00:00.000Z"
}
```

Comment rows add `postId`, `parentId`, `depth`, `numberOfReplies` and `html`; community rows add `description`, `weeklyVisitors`, `weeklyContributions`, `iconUrl` and `bannerUrl`; user rows add `karma`, `postKarma`, `commentKarma`, `iconUrl` and the account date in `createdAt`. Video posts list their Reddit video links in `videoUrls` (an HLS stream and, when Reddit offers one, an MP4 file).

### FAQ

**How do I scrape Reddit comments without the Reddit API?**
Paste the post URL into Reddit URLs (or a subreddit URL with Include comments on). The Actor returns each comment with author, score, depth, parent, date and text. You need no Reddit account or API key.

**How do I export all posts from a subreddit to CSV or Excel?**
Add the subreddit name, set Sort and Maximum posts per source, run, and download the dataset as CSV or Excel from the run page.

**Can I find Reddit posts and comments that mention my brand or a keyword?**
Yes. Put the words in Search terms and turn on Search for comments as well as posts. Use Sort = New with a schedule to keep an up-to-date list.

**Can I get Reddit posts and comments between two dates?**
Yes. Set Only posts since and Only posts until (Only comments since and Only comments until for comments). A plain date covers the whole day in UTC.

**Can I use Reddit data for sentiment analysis or an AI dataset?**
Yes. Each post and comment is one row with its text in plain form and HTML, score, date, author and subreddit, so you can download it as CSV or JSON and feed it to your analysis or RAG pipeline.

**What happens if my run gets close to its time limit?**
The Actor stops starting new pages about half a minute before the limit, keeps every row it already returned, adds a free row saying which inputs were not finished, and ends as Succeeded.

**Do I need a Reddit account?**
You need no account: the Actor returns what Reddit shows to anyone who is logged out.

### Pricing

You pay per result row (post, comment, community or user), plus a small start fee for each run that depends on the run's memory (2 GB by default, at most 4 GB). Rows that only explain why something was not returned - a subreddit that does not exist, a page Reddit would not show, the run reaching its time or budget limit - are free and say so in the `note` column.

Set a maximum charge for the run in Apify, and the Actor stops cleanly at that amount with a free row that tells you so.

### Limitations

- Only content Reddit shows without logging in is returned. Private, banned, quarantined and members-only subreddits come back as a free row that gives Reddit's reason, and NSFW pages that ask you to log in are skipped.
- r/all: Reddit sends visitors who are not logged in to its front page, which lists the same posts as r/popular, so that is what r/all returns.
- With comments on, each post's first page of comments (about 20-25, in Reddit's order) is read quickly. Asking for more than 20 comments per post makes the Actor load more comments on each post, which takes longer.
- Posts from search results include title, author, subreddit, score, comment count and date; their full text comes with Include comments on (the Actor then opens each post).
- Deleted comments without text or author are skipped and not charged. Email addresses and phone numbers inside text are masked.
- Subreddit info has weekly visitors and weekly contributions, which is what Reddit now shows instead of a member count.
- User search returns the profile link, karma, description and avatar shown in Reddit's search; account date and post/comment karma come when you add the user to Users.
- Media search results carry the title, author, subreddit and media links; score, date and text come with Include comments on (the Actor then opens each post). With a date filter, the Actor opens each post to read its date.
- A post search with "Only posts since" and no Time range uses the shortest range that still covers your date (past day, week, month or year), so nothing in your range is left out.
- When a date or flair filter makes the Actor open posts that turn out not to match, it stops after opening 30 such posts in one run and says so in a free row for each input it stopped.
- `numberOfReplies` counts the direct replies when Reddit shows all of them on the post page; when Reddit folds some replies behind "more replies", it is null rather than a guess.
- Video links expire after some time; download the videos soon after the run.
- Promoted posts (ads) in subreddit feeds are skipped; every post row has `isAd`.
- Author flair (the tag a user wears in a subreddit) is not returned: the pages Reddit shows without logging in do not include it.
- This Actor is not affiliated with Reddit. Please use the data in line with Reddit's terms and the privacy of its users.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

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

Subreddit, post, user or search pages on reddit.com, for example https://www.reddit.com/r/technology/top/?t=week, https://www.reddit.com/r/AskReddit/comments/abc123/, https://www.reddit.com/user/spez/ or https://www.reddit.com/search/?q=coffee. Leave empty if you use the fields below.

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

Subreddit names without r/, in any letter case, for example technology, askreddit or popular. Each one returns its posts in the order set in Sort. Leave empty if not needed.

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

Reddit user names without u/, in any letter case, for example spez. Each one returns the profile (karma, account date) and the user's posts and comments. Leave empty if not needed.

## `searches` (type: `array`):

Words to search on Reddit, one per line, for example "best crm for startups". Choose below whether to search posts, comments, communities, users or media. Leave empty if not needed.

## `searchPosts` (type: `boolean`):

Return posts that match the search terms. On by default.

## `searchComments` (type: `boolean`):

Also return comments that match the search terms, with the post they belong to. Off by default.

## `searchCommunities` (type: `boolean`):

Also return subreddits that match the search terms, with description and weekly visitors. Off by default.

## `searchUsers` (type: `boolean`):

Also return Reddit users whose name or profile matches the search terms, with profile link, karma, description and avatar. Always searches all of Reddit. Off by default.

## `searchMedia` (type: `boolean`):

Also return image and video posts that match the search terms, with their image and video links. Off by default.

## `searchCommunityName` (type: `string`):

Limit the search terms to one subreddit, for example technology. Leave empty to search all of Reddit.

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

Order of posts. For subreddits: hot, new, top or rising. For searches: relevance, hot, top, new or comments. Leave empty for Reddit's default (hot for subreddits, relevance for search). A sort written in a start URL wins over this field. A sort that does not apply (rising for a search, relevance or comments for a subreddit) stops the run with a free row.

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

For Top and for searches: hour, day, week, month, year or all. Leave empty for Reddit's default. With only subreddits that are not sorted by top, a time range stops the run with a free row (it would have no effect).

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

Stop after this many result rows (posts, comments, communities and users together) across all sources. Default 100.

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

Most posts (or search results) to return from each URL, subreddit, user or search term. Default 25.

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

Open each post and return its full text and its top comments. Turn off for a faster, cheaper list of posts only (search results then come without the post text). On by default.

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

Most comments to return for each post when comments are included, in the order Reddit shows them. Default 10.

## `includeCommunityInfo` (type: `boolean`):

Return one row per subreddit with its title, description, weekly visitors and weekly contributions. On by default.

## `includeUserPosts` (type: `boolean`):

For user pages, return the posts the user submitted. On by default.

## `includeUserComments` (type: `boolean`):

For user pages, return the comments the user wrote. On by default.

## `postDateLimit` (type: `string`):

Return only posts created on or after this date (YYYY-MM-DD). With Sort set to New, reading stops at the first page older than this date. Combine with "Only posts until" for a date range. Leave empty for no date limit.

## `commentDateLimit` (type: `string`):

Return only comments created on or after this date (YYYY-MM-DD). Leave empty for no date limit.

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

Return only posts created on or before this date (YYYY-MM-DD, the whole day in UTC) or time (for example 2026-01-31T12:00:00Z). Combine with "Only posts since" for a date range. Leave empty for no upper limit.

## `commentedBefore` (type: `string`):

Return only comments created on or before this date (YYYY-MM-DD, the whole day in UTC) or time. Combine with "Only comments since" for a date range. Leave empty for no upper limit.

## `onlyWithFlair` (type: `boolean`):

Return only posts that have a post flair (the tag such as Discussion or Question). For search results the Actor opens each post to read its flair. Off by default.

## `includeNSFW` (type: `boolean`):

Keep posts and communities that Reddit marks as NSFW (18+) when Reddit shows them without logging in. Turn off to drop them. On by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/technology/"
    }
  ],
  "searchPosts": true,
  "searchComments": false,
  "searchCommunities": false,
  "searchUsers": false,
  "searchMedia": false,
  "maxItems": 100,
  "maxPostsPerSource": 25,
  "includeComments": true,
  "maxCommentsPerPost": 10,
  "includeCommunityInfo": true,
  "includeUserPosts": true,
  "includeUserComments": true,
  "onlyWithFlair": false,
  "includeNSFW": true
}
```

# Actor output Schema

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

One row per Reddit post, comment, subreddit or user (dataType tells which): title, text, author, subreddit, score, upvote ratio, comment count, links, images and dates, plus subreddit info and user karma. Inputs that could not be read, and runs that stop before the time or budget limit, come back as a free row (dataType note) that says why.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.reddit.com/r/technology/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/reddit-thread-extractor").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 = { "startUrls": [{ "url": "https://www.reddit.com/r/technology/" }] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/reddit-thread-extractor").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 '{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/technology/"
    }
  ]
}' |
apify call neverempty/reddit-thread-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/reddit-thread-extractor"
        }
    }
}
```

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/XUn1d2IgrmehbKZWO/builds/SQpOxhI8fUpap9bFp/openapi.json
