# Reddit Scraper — Posts & Comments | from $1.50/1K (`bovi/reddit-scraper`) Actor

Scrape Reddit posts, comments, and user activity from any public subreddit. Returns 25+ fields: score, upvote ratio, flair, author, timestamps, parse\_confidence. No API key needed — backed by Arctic Shift archive with unlimited historical depth. MCP-callable.

- **URL**: https://apify.com/bovi/reddit-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Social media, Marketing, AI
- **Stats:** 7 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.94 / 1,000 reddit 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

Built for brand monitors, growth researchers, and AI agent pipelines that need Reddit data at scale without OAuth limits.

**Pricing: $1.50 per 1,000 posts · $0.50 per 1,000 comments (when `includeComments=true`)**

**Reddit Scraper** lets you scrape Reddit posts, comments, and user activity from any public subreddit — no API key, no OAuth, no proxy required. Returns 25+ fields per record including score, upvote ratio, flair, author, and timestamps. Backed by the **Arctic Shift Reddit archive** for unlimited historical depth — no 1000-post-per-subreddit cap that live Reddit imposes. MCP-callable for AI agents. Pay only per result scraped.

### Why This Reddit Scraper Beats the Alternatives

| | This scraper | trudax/reddit-scraper-lite | practicaltools/apify-reddit-api |
|---|:---:|:---:|:---:|
| Price | **$1.50/1000** | $3.40/1000 | $2.00/1000 |
| No proxy cost to buyer | ✓ | ✗ | ✗ |
| Historical data (no 1000-post cap) | ✓ | ✗ | ✗ |
| No OAuth API dependency | ✓ | ✓ | ✗ |
| parse\_confidence in every record | ✓ | ✗ | ✗ |
| 25+ fields | ✓ | ✓ | partial |
| Comments included | ✓ | partial | ✗ |

**Key advantage:** Competitors hitting live Reddit directly require residential proxy to avoid 403s — that cost passes to you. This actor uses Arctic Shift (free Reddit archive API) as its backend, so **you pay only for results, not proxy overhead**.

### Reddit Data Fields

| Field | Posts | Comments |
|---|:---:|:---:|
| id | ✓ | ✓ |
| type (`post`/`comment`) | ✓ | ✓ |
| subreddit | ✓ | ✓ |
| title | ✓ | — |
| body | ✓ | ✓ |
| author | ✓ | ✓ |
| score | ✓ | ✓ |
| upvote\_ratio | ✓ | — |
| num\_comments | ✓ | — |
| created\_utc (ISO-8601) | ✓ | ✓ |
| permalink | ✓ | ✓ |
| url | ✓ | ✓ |
| is\_self | ✓ | — |
| over\_18 (NSFW) | ✓ | — |
| flair\_text | ✓ | ✓ |
| domain | ✓ | — |
| subreddit\_subscribers | ✓ | ✓ |
| parent\_id | — | ✓ |
| depth | — | ✓ |
| is\_submitter (OP?) | — | ✓ |
| parse\_confidence | ✓ | ✓ |
| warnings | ✓ | ✓ |
| scraped\_at | ✓ | ✓ |

#### What `parse_confidence` Means

Every Reddit record includes a score from 0.0 to 1.0:

- **1.0** — all fields parsed cleanly
- **0.9–0.95** — minor field missing (e.g. deleted author)
- **< 0.5** — critical issue (missing ID, no data returned)

`warnings` lists machine-readable codes explaining any deductions — broken scrapes are visible in your dataset, not silently hidden.

### Reddit Scraper Use Cases

- **Brand monitoring** — track keyword mentions across niche subreddits
- **Lead generation** — find users asking questions your product solves
- **Sentiment analysis** — bulk-export posts and comments for NLP pipelines
- **Competitor research** — monitor product-related subreddits
- **Content strategy** — find top-performing posts by score or comment count
- **AI agent memory** — feed recent subreddit discussion into agent context

### How to Use Reddit Scraper

#### Scrape Reddit Subreddit Posts

```json
{
  "subreddits": ["python", "learnpython"],
  "sort": "new",
  "maxItems": 200,
  "includeComments": false
}
```

#### Scrape Reddit Posts + Comments Together

```json
{
  "subreddits": ["entrepreneur"],
  "sort": "new",
  "maxItems": 100,
  "includeComments": true,
  "maxCommentsPerPost": 25
}
```

#### Scrape Reddit User Activity

```json
{
  "users": ["spez", "some_username"],
  "maxItems": 50
}
```

#### Scrape via Reddit URL

```json
{
  "urls": ["https://www.reddit.com/r/investing/"],
  "maxItems": 200
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `subreddits` | string\[] | — | Subreddit names (e.g. `python`, `r/flask`) |
| `urls` | string\[] | — | Reddit subreddit or profile URLs |
| `users` | string\[] | — | Usernames to scrape (e.g. `spez`) |
| `sort` | `new`/`old` | `new` | Sort order |
| `maxItems` | integer | 100 | Max posts per subreddit or user |
| `includeComments` | boolean | false | Also scrape comments |
| `maxCommentsPerPost` | integer | 50 | Max comments per post |

### Sample Output

```json
{
  "type": "post",
  "id": "1d2e3f4",
  "subreddit": "python",
  "title": "What's the best async HTTP library in 2026?",
  "body": "Looking for recommendations for an async HTTP client...",
  "author": "user123",
  "score": 847,
  "upvote_ratio": 0.97,
  "num_comments": 62,
  "created_utc": "2026-05-20T14:32:11+00:00",
  "permalink": "/r/python/comments/1d2e3f4/whats_the_best_async_http_library_in_2026/",
  "url": "https://www.reddit.com/r/python/comments/1d2e3f4/",
  "flair_text": "Discussion",
  "subreddit_subscribers": 1200000,
  "parse_confidence": 1.0,
  "warnings": [],
  "scraped_at": "2026-06-05T09:00:00+00:00"
}
```

### Pricing — Pay Per Reddit Post or Comment

**$1.50 per 1,000 posts** · **$0.50 per 1,000 comments** (when `includeComments=true`) — PPE, no per-run fee. No proxy cost — Reddit data is fetched via Arctic Shift at no additional infrastructure charge. First $5 Apify credit covers ~3,300 post records.

### Data Source & Freshness

This actor fetches from **Arctic Shift** (`arctic-shift.photon-reddit.com`), a community-maintained Reddit archive based on historical data dumps. Data is updated continuously with an approximate 36-hour lag on engagement metrics (score, num\_comments) for very recent posts. Historical data goes back years with no per-subreddit post cap.

Arctic Shift is a free service with no uptime SLA. The `parse_confidence` and `warnings` fields in every record surface any API anomalies so you can filter them downstream.

### Use with AI Agents (MCP)

This Reddit scraper is callable as a **tool by AI agents** (Claude Desktop, Cursor, VS Code, n8n, LangGraph, CrewAI, or any MCP-compatible client) via Apify's hosted Model Context Protocol server.

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

Keep `maxItems` low (e.g. 25) when calling from agents to limit token volume.

### Frequently Asked Questions

**Does this Reddit scraper need an API key?**
No. It uses Arctic Shift (a community Reddit archive), not the official Reddit API. No OAuth, no app registration.

**Why is there a 36-hour lag?**
Arctic Shift syncs from Reddit data dumps continuously. Very recent posts (< 36h) may have slightly outdated score and num\_comments — all other fields are accurate.

**Can I get more than 1000 posts from a subreddit?**
Yes. Unlike live Reddit, Arctic Shift has no 1000-post cap. Use `maxItems` to control volume; the actor paginates via timestamps.

**Is residential proxy needed?**
No — this actor does not hit live Reddit endpoints. No proxy cost to you.

***

### Brand Monitoring & Incremental Scraping

Use `sinceDate` and Apify schedules to run this actor daily and get only new posts for ongoing brand-monitoring workflows. Set `includeComments=true` and a low `maxCommentsPerPost` for lightweight recurring runs that track sentiment changes over time.

***

*Not affiliated with Reddit. Data retrieved from Arctic Shift, a community-maintained public Reddit archive.*

### Integrations

Built for social-listening and research teams tracking communities, trends, and sentiment at scale — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Social Media Finder](https://apify.com/bovi/social-media-finder)
- [Telegram Channel Scraper](https://apify.com/bovi/telegram-channel-scraper)
- [Truth Social Scraper](https://apify.com/bovi/truth-social-scraper)
- [Twitch Scraper](https://apify.com/bovi/twitch-scraper)
- [Douyin Scraper](https://apify.com/bovi/douyin-scraper)
- [Maigret Username Osint](https://apify.com/bovi/maigret-username-osint)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

### Use it from your existing tools

#### Use with Claude Desktop / Cursor / Cline (MCP)

Load this actor as a tool in your AI assistant. Call it directly from your AI assistant via the Apify MCP server — no Store browsing needed. Paste this into your MCP client config (e.g. `claude_desktop_config.json`) and restart the client:

```json
{
  "mcpServers": {
    "apify-reddit-scraper": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "bovi/reddit-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Replace `YOUR_APIFY_TOKEN` with your own Apify API token (free at apify.com → Settings → Integrations). Curated to a handful of tools so the agent selects reliably.

#### Works with Clay

Run this actor as an HTTP enrichment step inside a Clay table:

- **Method:** `POST`
- **URL:** `https://api.apify.com/v2/acts/bovi~reddit-scraper/run-sync-get-dataset-items?token={{apify_token}}`
- **Body (JSON):** map your Clay columns to the actor input (see the Input section above), e.g. `{"subreddits": "{{clay_column}}"}`

The run finishes synchronously and returns the dataset rows straight into your Clay table. It runs on Apify's cloud under your own token and usage. Synchronous runs must complete within 300 seconds.

# Actor input Schema

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

Subreddit names to scrape posts from. Each item is a subreddit name (with or without 'r/' prefix). Example: \['python', 'learnpython', 'machinelearning']. Use this for topic/community-based sampling.

## `urls` (type: `array`):

Full Reddit URLs to scrape. Supports subreddit listing pages and user profile pages. Example: \['https://www.reddit.com/r/python/', 'https://www.reddit.com/user/spez/']. Use when you have a direct link rather than a subreddit name.

## `users` (type: `array`):

Reddit usernames to scrape posts and comments from. Each item is a username (with or without 'u/' prefix). Example: \['spez', 'gallowboob']. Use for user activity research.

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

Maximum number of posts (or comments) to return per subreddit or user. Keep low (25–100) for agent mid-conversation sampling; use higher values (500+) for bulk research exports.

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

Sort order for results. 'new' returns most recent posts first (default, best for current sentiment). 'old' returns oldest posts first.

## `searchQuery` (type: `string`):

Filter posts by title keyword. Works in combination with subreddits — e.g. set subreddits=\['python'] and searchQuery='async' to find Python posts about async. Leave empty to get all posts in the subreddit.

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

Set to true to also collect comments, in addition to posts. Comments appear as separate records with type='comment'. Increases result count and run cost. Default: false (posts only).

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

When includeComments is true: maximum number of comments to collect per post. Default: 50. Lower this to reduce token volume when using results with an AI agent.

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

Optional Apify proxy settings. This actor uses Arctic Shift (a free Reddit archive API) and does not require proxy for most runs. Enable only if your network blocks the archive endpoint.

## Actor input object example

```json
{
  "subreddits": [
    "python"
  ],
  "maxItems": 100,
  "sort": "new",
  "includeComments": false,
  "maxCommentsPerPost": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset containing Reddit Scraper records (type, subreddit, author, title, body, score, num\_comments, upvote\_ratio, created\_utc, permalink, parse\_confidence, scraped\_at).

# 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": [
        "python"
    ],
    "maxItems": 100,
    "sort": "new",
    "includeComments": false,
    "maxCommentsPerPost": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/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": ["python"],
    "maxItems": 100,
    "sort": "new",
    "includeComments": False,
    "maxCommentsPerPost": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/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 '{
  "subreddits": [
    "python"
  ],
  "maxItems": 100,
  "sort": "new",
  "includeComments": false,
  "maxCommentsPerPost": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call bovi/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/aRYybou7gMyCAYjCI/builds/lYyqojhAy6eC8z6sx/openapi.json