# Reddit Scraper API - Posts, Comments & Monitoring (`thirdwatch/reddit-scraper`) Actor

Scrape public Reddit posts, search, subreddits, media, and nested comments or monitor only newly observed posts. Anonymous read-only OAuth; no browser, proxy, login, cookies, or API key.

- **URL**: https://apify.com/thirdwatch/reddit-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 255 total users, 46 monthly users, 99.9% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.40 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Reddit Scraper API - Posts, Comments, Search & Monitoring

> **Thirdwatch portfolio:** 5K users across 88 public Actors, 2M+ records delivered, and >99% run success. [Explore all Thirdwatch Actors](https://apify.com/thirdwatch).

Extract public Reddit posts, subreddit listings, global search results, self-post text, engagement, media, and nested comments through Reddit's anonymous read-only OAuth API. No browser, Reddit login, cookies, user-supplied API key, or proxy.

### Why this Actor

- **Low-cost anonymous OAuth** — structured JSON at 256 MB, with no stealth-browser startup fee or residential transfer.
- **100 posts per page** — paginate automatically to 1,000 posts per query.
- **Three query modes in one field** — global search, subreddit listings, and search within a subreddit.
- **Full public post bodies** — self-post text, media, flair, awards, crossposts, and moderation flags arrive in the structured response.
- **Comments included in the post price** — embed up to 100 top or nested comments without paying per comment row.
- **Persistent new-post monitoring** — the first run creates a baseline; later complete runs return only unseen post IDs.
- **Zero unchanged result charges** — a scheduled monitor with no new posts writes no dataset rows.
- **No duplicate billing** — overlapping queries, URLs, and subreddit pages are deduplicated by Reddit post ID across the run.

### Query patterns

| Input | Behavior |
| --- | --- |
| `AI agents` | Search all public Reddit posts |
| `r/programming` | Browse a public subreddit using the selected sort |
| `r/programming: Python 3.14` | Search within one subreddit |
| `startUrls` | Paginate an existing Reddit listing/search page or fetch a post URL |
| `postUrls` | Fetch exact public posts and optionally their comments |

#### Basic subreddit run

```json
{
  "queries": ["r/programming", "r/python"],
  "sort": "new",
  "maxResults": 100
}
```

#### Global and subreddit-specific research

```json
{
  "queries": [
    "AI coding agents",
    "r/SaaS: customer support automation"
  ],
  "sort": "relevance",
  "timeFilter": "month",
  "maxResults": 250,
  "minScore": 5
}
```

#### Scheduled new-post monitoring

```json
{
  "queries": ["r/devops: alternative to", "r/sysadmin: recommend"],
  "sort": "new",
  "skipPinnedPosts": true,
  "maxResults": 50,
  "includeComments": true,
  "maxCommentsPerPost": 20,
  "monitorMode": "new-posts",
  "monitorStoreName": "infrastructure-buyer-signals"
}
```

Save that input as an Apify Task and attach a Schedule. The first successful run emits the current baseline with `changeType: "baseline"`. Later successful runs using the same monitor name emit only unseen IDs with `changeType: "new_post"`. The Actor commits state after publishing rows, providing at-least-once delivery. It refuses to advance state if any configured target is incomplete.

Use one `monitorStoreName` per independent watch and do not overlap runs that share it. Changing a query, sort, filter, or result depth changes the cohort; use a new monitor name. `newerThan` remains available for one-off timestamp-filtered exports but is not needed for persistent monitoring.

#### Post and comment extraction

```json
{
  "postUrls": [
    "https://www.reddit.com/r/programming/comments/POST_ID/example/"
  ],
  "includeComments": true,
  "maxCommentsPerPost": 50,
  "maxCommentDepth": 3
}
```

### Output fields

Every post row includes:

- identity: `id`, `title`, `url`, `permalink`, `sourceQuery`
- author/community: `author`, `subreddit`, `flair`
- content: `selftext`, `post_hint`, `domain`, `mediaUrl`, `thumbnail`, `gallery_images`
- engagement: `score`, `upvoteRatio`, `numComments`, `gildingCount`
- flags: `isNSFW`, `is_spoiler`, `is_stickied`, `is_self`, `is_video`, `is_crosspost`, `is_locked`, `is_archived`
- timestamps: `created`, `scrapedAt`
- monitoring: `changeType`, `firstSeenAt` when `monitorMode` is `new-posts`
- optional comments: `topComments[]` with `id`, `parentId`, `author`, `body`, `score`, `depth`, `created`, and `permalink`

#### Example result

```json
{
  "id": "1uxtv30",
  "title": "New Python type checker",
  "author": "TheSeriousTrader",
  "subreddit": "Python",
  "url": "https://www.reddit.com/r/Python/comments/1uxtv30/new_python_type_checker/",
  "permalink": "https://www.reddit.com/r/Python/comments/1uxtv30/new_python_type_checker/",
  "selftext": "Was checking out some Python type checkers...",
  "score": 42,
  "upvoteRatio": 0.88,
  "numComments": 16,
  "created": "2026-07-16T05:39:00+00:00",
  "flair": "Discussion",
  "is_self": true,
  "topComments": []
}
```

### Live pricing

You pay only for unique post rows written to the dataset. Empty searches, duplicates, failed requests, and comments embedded inside a post row do not create additional result charges.

| Apify tier | Price per 1,000 posts |
| --- | ---: |
| FREE | $1.00 |
| BRONZE | $0.80 |
| SILVER | $0.60 |
| GOLD | $0.40 |

There is no browser-start or proxy fee. The **Pricing** tab is the authoritative live price.

### Reliability and responsible use

- The Actor collects public Reddit content only. Private, banned, quarantined, removed, or login-only content is unavailable.
- Requests are globally rate-limited with bounded retries for `429`, authorization refreshes, timeouts, and transient network failures.
- Persistent monitors keep at most 50,000 post identities. The oldest identities can eventually age out of extremely high-volume watches.
- Monitoring visits every configured target but buffers at most 2,000 current post observations before diffing. With large watchlists, the Actor lowers `maxResults` evenly per listing; split broader cohorts into separate Tasks.
- Monitoring state updates only after every configured target completes. A failed page or deadline guard fails closed instead of corrupting the baseline.
- Reddit scores and comment counts can change between requests and may be hidden for very new posts.
- Comment-enabled listing runs are capped at 100 posts total across all queries; exact `postUrls` reuse their detail response and remain separate.
- Comments come from Reddit's initial public comment tree; hidden “load more comments” branches are not expanded.
- Search relevance and geographic availability are controlled by Reddit.

### Workflows and guides

- [Scrape Reddit for community research](https://thirdwatch.dev/blog/scrape-reddit-for-community-research)
- [Monitor subreddits for B2B buyer signals](https://thirdwatch.dev/blog/monitor-subreddits-for-b2b-buyer-signals)
- [Track Reddit discourse on product launches](https://thirdwatch.dev/blog/track-reddit-discourse-on-product-launches)

Pairs well with [Twitter/X Scraper](https://apify.com/thirdwatch/twitter-scraper?fpr=9m2cd6), [Google News Scraper](https://apify.com/thirdwatch/google-news-scraper?fpr=9m2cd6), and [YouTube Scraper](https://apify.com/thirdwatch/youtube-scraper?fpr=9m2cd6) for cross-channel listening.

Last verified: 2026-07

# Actor input Schema

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

Plain text searches all Reddit. Use r/python for a subreddit listing or r/python: asyncio for search within one subreddit.

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

Existing public Reddit URLs. Subreddit/search pages are paginated; post URLs are extracted directly.

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

Fetch exact public Reddit posts and, optionally, their comment threads.

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

How subreddit and search results are ordered.

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

Time range for top and relevance searches.

## `maxResults` (type: `integer`):

Maximum unique posts returned for each query or listing URL. Pagination is automatic in batches of up to 100. Persistent monitors distribute a 2,000-observation safety budget across listing targets.

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

Embed public top and nested comments in each post row. Comment-enabled listing runs are capped at 100 posts total across all queries to respect Reddit and the run timeout.

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

Maximum public comments embedded in each post row when comments are enabled.

## `maxCommentDepth` (type: `integer`):

Zero keeps top-level comments only; higher values include nested replies up to that depth.

## `minScore` (type: `integer`):

Only write posts at or above this visible Reddit score.

## `skipPinnedPosts` (type: `boolean`):

Exclude moderator-pinned or stickied posts from results.

## `newerThan` (type: `string`):

ISO 8601 timestamp or date for one-off incremental exports, for example 2026-07-01 or 2026-07-01T00:00:00Z. Persistent monitors usually leave this empty.

## `monitorMode` (type: `string`):

Return every current post, or persist a baseline and return only posts not seen by this watch. An unchanged new-posts run writes no billable result rows.

## `monitorStoreName` (type: `string`):

Stable identity for one scheduled watch. Reuse the same name and input on every run; use a different name for each independent monitor.

## `maxConcurrency` (type: `integer`):

Parallel parsing tasks for bodies/comments. Actual Reddit requests remain globally rate-limited.

## `requestDelaySecs` (type: `number`):

Minimum delay between anonymous Reddit API requests. Keep at 0.65 seconds unless you need a gentler crawl.

## Actor input object example

```json
{
  "queries": [
    "r/programming",
    "AI agents"
  ],
  "startUrls": [],
  "postUrls": [],
  "sort": "hot",
  "timeFilter": "all",
  "maxResults": 100,
  "includeComments": false,
  "maxCommentsPerPost": 10,
  "maxCommentDepth": 1,
  "minScore": 0,
  "skipPinnedPosts": false,
  "monitorMode": "all",
  "maxConcurrency": 3,
  "requestDelaySecs": 0.65
}
```

# 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 = {
    "queries": [
        "r/programming",
        "AI agents"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/reddit-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "r/programming",
    "AI agents"
  ]
}' |
apify call thirdwatch/reddit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=thirdwatch/reddit-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/rVyDJsbG80Y2j5sHa/builds/1s0hU4phFcRHnueke/openapi.json