# Reddit Scraper: Posts, Comments, Subreddits & Search (`automation-lab/reddit-scraper`) Actor

Scrape Reddit posts, comment threads, subreddits, user posts and search results, with several keywords per run. No login or API key. From $1.15 per 1,000 posts and $0.58 per 1,000 comments; empty runs are free. Export JSON, CSV, Excel or AI/RAG formats.

- **URL**: https://apify.com/automation-lab/reddit-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media, AI, Lead generation
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 10,328 total users, 3,595 monthly users, 99.7% runs succeeded, 41 bookmarks
- **User rating**: 4.73 out of 5 stars

## Pricing

from $0.60 / 1,000 post scrapeds

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

### What does Reddit Scraper do?

Reddit Scraper extracts Reddit posts, comment threads, subreddit listings, user posts and search results from public Reddit pages, with no Reddit account or API key. Use it for brand and keyword monitoring, market and product research, lead discovery, and AI/RAG datasets. Run several search keywords and subreddits in one run, and export to JSON, CSV or Excel.

Posts cost **from $1.15 per 1,000** and comments **from $0.75 per 1,000** (from November 17, 2026; less until then), cheaper than most Reddit scrapers in Apify Store. You pay nothing for a run that returns no results.

**Reddit access note:** When Reddit limits logged-out access to its web pages, the Actor reads Reddit's public feeds for subreddit listings, user posts and post URLs as a backup. Feed results have post text, author, links and dates, but `score`, `upvoteRatio` and `numComments` are 0 and comments have no depth or parent IDs; each such row says so in its `warnings`. Search needs Reddit's web pages, so a search target is reported as unavailable (and not charged) if Reddit refuses it.

### Server API: short HTTP requests

Reddit Scraper is also a Server Actor. Besides normal runs, it answers short HTTP requests directly, without starting a run for each one. Copy the server URL from the Actor's **Server** tab (do not build it from the Actor name) and authenticate with your Apify token. Normal Actor runs keep the full input and dataset output; use them for larger or longer jobs.

```bash
curl -sS "$SERVER_URL/subreddit/posts" -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' -d '{"subreddit":"AskReddit","sort":"new","maxPosts":3}'
curl -sS "$SERVER_URL/post/comments" -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' -d '{"postId":"1abcde","maxComments":10}'
```

| Method and path | Input | Output and charge |
| --- | --- | --- |
| `GET /` | None | `ready: true`, the routes and limits; no scraping or charge |
| `POST /subreddit/posts` | `subreddit` (2–21 letters, digits or underscores), optional `sort` (`hot`, `new`, `top`), `maxPosts` (1–10, default 5) | `{ok,count,results}` with the same post records as the dataset; the usual per-post price, charged only when results are returned; no start fee |
| `POST /post/comments` | `postId` (5–12 letters or digits), optional `maxComments` (1–20, default 10) | `{ok,count,results}` with the post and its available comments; the usual post and per-comment prices, charged only when results are returned; no start fee |

Bodies must be JSON and at most 2048 bytes. Each request has a 60-second deadline and a 256 KiB response cap, and one server works on at most four requests at once. Nothing is cached between callers. Errors use `{ "ok": false, "error": { "code": "...", "message": "...", "retryable": false } }`: 400 invalid input or JSON, 402 spending limit, 404 no accessible results or unknown route, 405 wrong method, 413 size limit, 415 media type, 502 Reddit or charging failure, 503 server busy or stopping, 504 timeout. Retry only when `retryable` is true. A successful answer can carry `warning: { code: "CHARGE_INCOMPLETE" }` when only part of its charge went through; the results are still complete and you are charged only for what went through. The Server tab shows the full OpenAPI description for each route and status.

### Use this with a brand monitoring stack

Apify's brand-monitoring guide shows why the best monitoring setup combines multiple channels instead of relying on one dashboard. Use Reddit Scraper as the community-discussion layer, then pair it with:

- [Twitter/X Scraper](https://apify.com/automation-lab/twitter-scraper) for social search, campaign hashtags, and public profile monitoring
- [Threads Scraper](https://apify.com/automation-lab/threads-scraper) for public Threads posts and keyword searches
- [G2 Reviews & Products Scraper](https://apify.com/automation-lab/g2-scraper) for B2B review intelligence and competitor sentiment
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) for consumer review monitoring
- [Google News Scraper](https://apify.com/automation-lab/google-news-scraper) for media coverage and PR alerts
- [Website Change Monitor](https://apify.com/automation-lab/website-change-monitor) for competitor pricing, changelog, and landing-page changes

Together these actors form a custom brand-monitoring pipeline on Apify: social conversations, review sites, news coverage, and owned-web changes in one workflow.

### Who is it for?

Reddit Scraper is built for anyone who needs Reddit data at scale without dealing with Reddit's restrictive official API:

🔬 **Researchers** — collect public opinion data, survey sentiment on topics, build datasets for academic studies
📊 **Market analysts** — track brand mentions, product feedback, and competitor discussions across subreddits
📈 **SEO & content marketers** — discover trending topics, find content ideas, and monitor keyword discussions
🤖 **AI/ML engineers** — gather training data, build sentiment analysis datasets, or feed LLM pipelines with real conversations
📰 **Journalists** — monitor communities for breaking stories, track public reactions to events
🏢 **Product managers** — collect user feedback from product subreddits, track feature requests and bug reports
💼 **Lead generation teams** — find potential customers asking for solutions your product solves
📉 **Social listening agencies** — monitor Reddit alongside other platforms for brand and reputation tracking

### Why use Reddit Scraper?

✅ **Working Reddit scraper** — restored for practical Reddit monitoring and public data export
🔎 **Search + listing coverage** — subreddit hot/new/top/rising listings and Reddit search, with several search keywords per run
📦 **Posts and comment threads in one actor** — nested replies with depth and parent IDs, from listings, searches or direct post URLs
🔗 **Flexible input types** — subreddits, posts, users, search queries, or just paste a Reddit URL
⚡ **Fast, lightweight runs** — designed for low-overhead Reddit collection
✅ **Clean, AI-ready output** — structured fields with consistent naming, ready for analytics, LLM training, RAG pipelines, and AI agent workflows
📄 **Pagination built in** — scrape hundreds or thousands of search/listing posts automatically
💰 **Pay only for results** — pay-per-event pricing, no monthly subscription
🔑 **No API key required** — works without Reddit developer credentials
🔍 **Keyword filtering** — filter results to only keep posts matching specific terms

### What data can you extract from Reddit?

**Post fields:**

| Field | Description |
|-------|-------------|
| title | Post title |
| author | Reddit username |
| subreddit | Subreddit name |
| score | Best-effort net upvotes; may be `0` when Reddit does not expose vote data publicly |
| upvoteRatio | Best-effort upvote percentage (0-1); may be `0` or unavailable on public recovery paths |
| numComments | Source-reported comment count when available; legacy `0` means unknown, not zero extracted rows |
| sourceCommentCount | Independent public-source count, or `null` when unavailable; may include deleted/unavailable nodes |
| extractedCommentCount | Distinct useful comments selected after per-post caps, before any run-wide charge/deadline interruption |
| commentCoverage | `unverified`: no complete-thread guarantee |
| createdAt | ISO 8601 timestamp |
| url | Full Reddit URL |
| selfText | Post body text |
| link | External link (for link posts) |
| domain | Link domain |
| isVideo, isSelf, isNSFW, isSpoiler | Content flags, as Reddit marks the post |
| linkFlairText | Post flair (empty when the post has none; not shown on search results) |
| totalAwards | Award count |
| subredditSubscribers | Always `null`: Reddit's public post feeds do not show community size |
| imageUrls | Image URLs of image and gallery posts |
| thumbnail | Thumbnail URL (link, image and video posts) |

**Comment fields:**

| Field | Description |
|-------|-------------|
| author | Commenter username |
| body | Comment text |
| score | Best-effort net upvotes; may be `0` when Reddit does not expose vote data publicly |
| createdAt | ISO 8601 timestamp |
| depth | Known nesting level (`0` = top-level, `-1` = unknown); never clamped to a lower level |
| isSubmitter | Whether commenter is the post author |
| parentId | Parent comment/post ID |
| replies | Number of direct replies |
| postId | Parent post ID |
| postTitle | Parent post title |
| targetCommentId | Requested comment ID when targeted comment context mode is used |
| isTargetComment | Whether this comment is the requested target comment |
| commentContextClassification | Best-known role in the focused context output (`target` or `context`) |

### How much does it cost to scrape Reddit?

This Actor uses **pay-per-event** pricing — you pay only for what you scrape. No monthly subscription. Platform costs are **included**.

For broad searches or unlimited modes (`maxPostsPerSource: 0`), set **Maximum charge per run** in the actor run settings before starting. The actor now stops automatically once the cap is reached, but it only checks this when charging events, so a hard cap is still required to prevent overage on large jobs.

Pricing is tiered — the more you use, the cheaper each item gets. **The prices below apply from November 17, 2026 (00:00 UTC).** Until then, the earlier, lower prices apply: comments cost about 23% less on FREE, BRONZE, SILVER and GOLD, and PLATINUM and DIAMOND pay less than GOLD for both posts and comments (comments about 49% and 64% less than the new price). The Pricing tab in Apify Console always shows the price you pay today.

| Event | FREE tier | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|-------|-----------|--------|--------|------|----------|---------|
| **Actor start** (charged with the first result) | $0.003/run | $0.003/run | $0.003/run | $0.003/run | $0.003/run | $0.003/run |
| **Per post** | $0.00115 | $0.001 | $0.00078 | $0.0006 | $0.0006 | $0.0006 |
| **Per comment** | $0.00075 | $0.00065 | $0.00051 | $0.00039 | $0.00039 | $0.00039 |

At the FREE tier, that's **$1.15 per 1,000 posts** and **$0.75 per 1,000 comments** from November 17. A run with invalid input or no results is not charged. Higher usage tiers get significant discounts — GOLD and above pay about half the FREE post price.

**Real-world cost examples (FREE tier):**

| Input | Results | Duration | Cost |
|-------|---------|----------|------|
| 1 subreddit, 100 posts | 100 posts | ~15s | ~$0.12 |
| 5 subreddits, 50 posts each | 250 posts | ~30s | ~$0.29 |
| 1 post + 200 comments | 201 items | ~5s | ~$0.15 |
| Search "AI", 100 results | 100 posts | ~15s | ~$0.12 |
| 1 subreddit, 5 posts + 3 comments each | 20 items | ~12s | ~$0.02 |

### How do I search Reddit posts and comments?

1. Go to the [Reddit Scraper input page](https://console.apify.com/actors/aYMxR9AqRjxmgzcwB)
2. Add Reddit URLs to the **Reddit URLs** field — any of these formats work:
   - `https://www.reddit.com/r/technology/`
   - `https://www.reddit.com/r/AskReddit/comments/abc123/post-title/`
   - `https://www.reddit.com/user/spez/`
   - `r/technology` or just `technology`
3. Or enter a **Search Query** to search across Reddit
4. Set **Max Posts per Source** to control how many posts to scrape
5. Enable **Include Comments** if you also want comment data
6. Click **Start** and wait for results
7. Download your data as JSON, CSV, or Excel from the **Dataset** tab

#### Optional connector export

By default, Reddit Scraper only writes results to the Apify dataset. Batch runs may explicitly opt in to one best-effort messaging summary after dataset records are saved. Server API routes do not accept connector delivery fields. This is a narrow messaging contract, not a general Notion/Slack integration or automatic writable-tool discovery; service-specific compatibility and live platform-proxy delivery are not guaranteed.

Guardrails:

- Select a connector **and** supply an exact `mcpDestinationToolName` (`send_message` or `post_message`) **and** an explicit `mcpDestinationTarget`. Missing intent is refused, with no automatic fallback.
- Third-party credentials remain with Apify connectors. The runtime uses `ACTOR_MCP_CONNECTOR_BASE_URL`, falling back to `APIFY_MCP_PROXY_URL` only when the documented variable is absent. A malformed documented value never falls back to another endpoint.
- Both proxy declaration and Actor checks require explicitly non-destructive tools (`destructiveHint=false`); read-only, unannotated, destructive and unknown operations are refused. Tool annotations are upstream claims, not independent proof of safety: choose only a connector and destination you trust.
- Supported tool schemas are string-only objects requiring `text` and exactly one of `channel`, `channel_id`, `destination`, or `target`, with an optional `title`. Required values, string lengths and enums are validated. Unknown fields/constraints, nested schemas, ambiguous targets and page/database/create operations are refused without a call. Destination values are limited to 256 UTF-8 bytes, without control characters.
- `mcpExportMaxItems` samples at most 25 records (default 10); the complete summary is capped at 8192 UTF-8 bytes, including a truncation notice. Full extraction, dataset output and charges are unchanged.
- Only a non-error MCP response is logged as **acknowledged**, not as independently verified delivery. `isError`, schema/refusal and transport failures produce categorical warnings without raw errors, private destination arguments or response bodies. Calls are not retried; a transport timeout can leave delivery unknown.
- Connector failures never delete dataset results or fail completed extraction. Connector/destination values are redacted from private diagnostic snapshots.

**Example MCP summary input:**

```json
{
    "urls": ["https://www.reddit.com/r/technology/"],
    "maxPostsPerSource": 10,
    "mcpDestinationConnector": "conn_your_connector_id",
    "mcpDestinationToolName": "send_message",
    "mcpDestinationTarget": "your-channel-id",
    "mcpExportMaxItems": 5
}
```

**Example input:**

```json
{
    "urls": ["https://www.reddit.com/r/technology/"],
    "maxPostsPerSource": 100,
    "sort": "hot",
    "includeComments": false
}
```

**Scraping a specific post with comments:**

```json
{
    "urls": ["https://www.reddit.com/r/technology/comments/abc123/some-post-title/"],
    "includeComments": true,
    "maxCommentsPerPost": 50,
    "commentDepth": 3
}
```

**Focused context for a specific comment URL:**

```json
{
    "urls": ["https://www.reddit.com/r/AskReddit/comments/abc123/post-title/def456/"],
    "commentContextMode": true,
    "commentContextDepth": 3,
    "maxCommentsPerPost": 25
}
```

Targeted comment context mode preserves the comment ID in the URL, loads the post with its available public comments, and flags the target comment (`isTargetComment`, `targetCommentFound`). It is best-effort: when the target comment is not among the available comments, output warnings say so instead of claiming a complete thread reconstruction.

**MCP / AI assistant single-URL aliases:**

Reddit **Share → Copy link** URLs (`https://www.reddit.com/r/<subreddit>/s/<token>`) are resolved to the intended post before scraping. Resolution reads redirect headers only, with at most one direct request and one US residential request if Reddit blocks the direct route. Intermediate, unsafe, or unresolved redirects fail clearly instead of substituting subreddit posts. If resolution fails, open the post and copy its canonical HTTPS `/r/<subreddit>/comments/<post-id>/...` URL. Resolution does not add charge events or change comment limits.

The canonical field is `urls`, but MCP and LLM tools sometimes send a single URL as `url`, `comment_url`, or `commentUrl`. Those aliases are accepted and normalized automatically:

```json
{
    "comment_url": "https://www.reddit.com/r/AskReddit/comments/abc123/post-title/def456/",
    "commentContextMode": true,
    "commentContextDepth": 3,
    "maxCommentsPerPost": 25
}
```

If no valid `urls`, `url`, `comment_url`, `commentUrl`, `searchQuery` or `searchQueries` is provided, the run saves a diagnostic row, sets a clear status message and charges nothing.

**Several searches in one run:**

```json
{
    "searchQueries": ["Notion", "Asana", "Monday.com"],
    "sort": "new",
    "timeFilter": "week",
    "maxPostsPerSource": 50
}
```

**Searching Reddit with keyword filtering:**

```json
{
    "searchQuery": "best project management tools",
    "searchSubreddit": "productivity",
    "sort": "relevance",
    "timeFilter": "month",
    "maxPostsPerSource": 50,
    "filterKeywords": ["Notion", "Asana", "Monday"]
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| urls | string\[] | — | Reddit URLs to scrape (subreddits, posts, users, search URLs) |
| url | string/string\[] | — | Compatibility alias for tools that send one URL instead of `urls` |
| comment_url / commentUrl | string/string\[] | — | Compatibility aliases for single Reddit comment URLs; can be used with `commentContextMode` |
| searchQuery | string | — | Search Reddit for this query |
| searchQueries | string\[] | — | More search queries; each one is searched separately with the same settings |
| searchSubreddit | string | — | Limit search to a specific subreddit |
| sort | enum | hot | Sort order: hot, new, top, rising, relevance |
| timeFilter | enum | week | Time filter for top/relevance: hour, day, week, month, year, all |
| maxPostsPerSource | integer | 100 | Max posts per subreddit/search/user. 0 = unlimited |
| includeComments | boolean | false | Also scrape comments for each post |
| maxCommentsPerPost | integer | 100 | Max comments per post |
| commentDepth | integer | 3 | Known reply levels to include (1–10): 1 includes depth 0; 10 includes depths 0–9. Unknown-depth comments remain `-1` |
| commentContextMode | boolean | false | For Reddit comment URLs, fetch a focused best-effort context around the target comment instead of generic post comments |
| commentContextDepth | integer | 3 | Kept for compatibility; the available comment tree is returned and the target comment is flagged |
| filterKeywords | string\[] | \[] | Only keep posts containing at least one keyword (case-insensitive). Leave empty to keep all |

#### Coverage notes

The default mode is recommended for most users. Coverage varies by input type and by what Reddit exposes publicly at run time:

- Subreddit listings and Reddit search are the strongest paths.
- User pages and direct post pages are best-effort and may return fewer fields.
- With `includeComments=true`, ordinary batch post/listing requests use bounded public comment-tree, "more replies" and subthread expansion. A short-lived anonymous Chromium bootstrap may establish a residential session; the browser is closed before HTTP expansion. No login, CAPTCHA solving or external data supplier is used.
- `maxCommentsPerPost` caps distinct available comments **after** depth filtering, not Reddit's total. Known depths are preserved; unknown-depth comments remain `depth=-1` with an empty parent instead of being labeled top-level. `sort=new` orders the merged comments by creation time. Other sorts retain best-effort public tree order.
- Public expansion stops at the output cap, request/response guard, access failure or work deadline. Coverage remains `unverified`, even after public cursors are exhausted: deleted, unavailable and unexposed nodes can remain. `extractedCommentCount` is the selected output count, not an independent total; a later run-wide charge/deadline stop can emit fewer rows. Read `sourceCommentCount` separately.
- The Server API `/post/comments` route and post-only direct URLs read comments over plain HTTP and never launch a browser. Metadata `enrichmentMode` and `sourceMode` are accepted for compatibility but no longer change behavior.
- Browser/session state is invocation-local and never shared across Server API callers or persisted. Existing output events/prices and connector restrictions are unchanged. Complete historical parity and every-comment retrieval are not guaranteed.
- Targeted comment context mode is a flagged view of the available public comments, not a full tree reconstruction; target-comment availability depends on Reddit's public page.
- Search results include title, author, subreddit, date, score and comment count. Text-post bodies are enriched from public embeds when available; media and link-card embeds are skipped. Subreddit, user and direct post results include available bodies.
- `subredditSubscribers` is `null`, and full media metadata (video files, gallery captions) is not included, because Reddit's public post feeds do not show them.
- Logs include warnings when an input returns partial or degraded results so output caveats are visible in the run.

### Output example

**Post:**

```json
{
    "type": "post",
    "id": "1qw5kwf",
    "title": "3 Teen Sisters Jump to Their Deaths from 9th Floor Apartment After Parents Remove Access to Phone",
    "author": "Sandstorm400",
    "subreddit": "technology",
    "score": 0,
    "upvoteRatio": 0,
    "numComments": 1363,
    "createdAt": "2026-02-05T00:04:58.000Z",
    "url": "https://www.reddit.com/r/technology/comments/1qw5kwf/3_teen_sisters_jump_to_their_deaths_from_9th/",
    "permalink": "/r/technology/comments/1qw5kwf/3_teen_sisters_jump_to_their_deaths_from_9th/",
    "selfText": "",
    "link": "https://people.com/3-sisters-jumping-deaths-online-gaming-addiction-11899069",
    "domain": "people.com",
    "isVideo": false,
    "isSelf": false,
    "isNSFW": false,
    "isSpoiler": false,
    "isStickied": false,
    "thumbnail": "https://external-preview.redd.it/...",
    "linkFlairText": "Society",
    "totalAwards": 0,
    "subredditSubscribers": null,
    "imageUrls": [],
    "scrapedAt": "2026-02-05T12:33:50.000Z",
    "warnings": ["Some fields are limited because Reddit restricts automated access. Score/upvoteRatio are best-effort and may be 0 when Reddit does not expose vote data publicly. subredditSubscribers is null because Reddit post feeds do not expose community size."]
}
```

**Comment:**

```json
{
    "type": "comment",
    "id": "m3abc12",
    "postId": "1qw5kwf",
    "postTitle": "3 Teen Sisters Jump to Their Deaths...",
    "author": "commenter123",
    "body": "This is heartbreaking. Phone addiction in teens is a serious issue.",
    "score": 0,
    "createdAt": "2026-02-05T01:15:00.000Z",
    "permalink": "/r/technology/comments/1qw5kwf/.../m3abc12",
    "depth": 0,
    "isSubmitter": false,
    "parentId": "t3_1qw5kwf",
    "replies": 12,
    "scrapedAt": "2026-02-05T12:33:52.000Z",
    "warnings": ["Some comment metadata is limited because Reddit restricts automated access. Comment score is best-effort and may be 0 when Reddit does not expose vote data publicly. Nested tree fields may be unavailable or approximate."]
}
```

### How do I get the best results from Reddit Scraper?

🎯 **Start small** — test with 5-10 posts before running large scrapes
📊 **Use sort + time filter** — `sort: "top"` with `timeFilter: "month"` gets the most popular content
💬 **Comments cost extra** — only enable `includeComments` when you need them
📋 **Multiple subreddits** — add multiple URLs to scrape several subreddits in one run
🔍 **Search within subreddit** — use `searchSubreddit` to limit search to a specific community
🔗 **Direct post URLs** — paste a specific post URL to get that post + its comments
🏷️ **Keyword filtering** — use `filterKeywords` to keep only relevant posts when Reddit search returns loose matches
📅 **Time-slice large scrapes** — for larger collections, run multiple searches with different `timeFilter` values (month, year, all)
🔄 **Scheduled runs** — set up recurring runs to monitor subreddits daily or weekly

### How do I keep Reddit scrapes reliable?

Start with small test runs, then increase limits gradually once the output matches your needs:

🕐 **Plan around pagination limits** — very large collections may need multiple runs with different `timeFilter` values (e.g., `month`, `year`, `all`) to cover older content.

🔍 **Prefer targeted inputs** — specific subreddits, search terms, and keyword filters usually produce cleaner datasets than very broad searches.

📦 **Split very large jobs** — for high-volume monitoring, use several smaller scheduled runs instead of one oversized run.

### Reddit data export: how to download Reddit posts to CSV, Excel, or JSON

Reddit Scraper outputs data to Apify's cloud dataset, which you can download in multiple formats immediately after each run:

📄 **JSON** — full structured output, best for developers and data pipelines. Each post and comment is a separate JSON object with all available fields.

📊 **CSV** — flat table format, opens directly in Excel, Google Sheets, or any data tool. Nested fields (like `imageUrls`) are serialized as strings in CSV mode.

📗 **Excel (.xlsx)** — download a ready-to-open spreadsheet. Same structure as CSV but formatted for Microsoft Excel.

🔗 **Direct dataset URL** — after a run, your dataset gets a permanent URL. You can download data programmatically at any time:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv" \
  -H "Authorization: Bearer YOUR_API_TOKEN" > reddit_posts.csv
```

📅 **Scheduled exports** — combine with Apify's scheduler to run the scraper daily and auto-export new posts to Google Sheets or a webhook endpoint.

🗄️ **Data warehouse integration** — pipe exports directly to BigQuery, Snowflake, or PostgreSQL using Apify integrations for long-term storage and trend analysis.

### How to monitor Reddit for brand mentions

Reddit is one of the most valuable sources for unsolicited brand feedback — people discuss products candidly in topic-specific communities. Here is how to set up ongoing brand monitoring with Reddit Scraper:

**1. Search for brand name mentions (add product and competitor names as more queries):**

```json
{
    "searchQueries": ["YourBrandName", "YourProductName", "CompetitorName"],
    "sort": "new",
    "timeFilter": "day",
    "maxPostsPerSource": 100,
    "includeComments": false
}
```

**2. Monitor specific product subreddits:**

```json
{
    "urls": [
        "https://www.reddit.com/r/YourProductSubreddit/new/",
        "https://www.reddit.com/r/CompetitorSubreddit/new/"
    ],
    "maxPostsPerSource": 50,
    "includeComments": true,
    "maxCommentsPerPost": 20
}
```

**3. Schedule it to run daily** — use Apify's built-in scheduler to run the actor every 24 hours. New posts and mentions land in a fresh dataset each time.

**4. Connect to Slack or email** — use Apify's Slack integration or a webhook to get notified immediately when new brand mentions are found.

**5. Filter for sentiment signals** — use `filterKeywords` to focus only on posts containing words like your product name, competitor names, or problem keywords:

```json
{
    "searchQuery": "project management software",
    "filterKeywords": ["Notion", "Asana", "ClickUp", "Monday"]
}
```

This workflow gives you a near-real-time stream of Reddit brand mentions without maintaining a developer account or paying for the Reddit API.

### How to use Reddit data for AI and LLM workflows

Reddit Scraper includes **three output formats** designed for different AI/ML workflows. Set the `outputFormat` input field to choose your format.

> **Pricing note for AI formats:** When using `jsonl-finetune` or `rag-markdown`, you are charged only for posts (not comments). Available comments are bundled into the transformed post record at no extra charge; no separate comment records are emitted in these formats. When Reddit exposes no comments, the Actor still returns one valid transformed record per post.

#### Format: `default` (standard JSON)

The default output is backward-compatible structured JSON with all post and comment fields. Use this for general-purpose analysis, brand monitoring, and data pipelines.

#### Format: `jsonl-finetune` — LLM supervised fine-tuning (SFT)

Each output record is a single training example in the OpenAI chat format (system / user / assistant messages), ready for supervised fine-tuning with OpenAI, Hugging Face, or any SFT framework.

- **System message**: analytical role instruction
- **User message**: post title + body text
- **Assistant message**: available comment text and author metadata in the scraped order; comment score is included only as best-effort metadata. If no public comments are available, it says so explicitly
- **Metadata**: subreddit, best-effort score/upvote ratio, post date — use vote fields cautiously because Reddit may omit them on public recovery paths

**Example input:**

```json
{
    "urls": ["https://www.reddit.com/r/MachineLearning/"],
    "maxPostsPerSource": 500,
    "includeComments": true,
    "maxCommentsPerPost": 10,
    "commentDepth": 1,
    "outputFormat": "jsonl-finetune"
}
```

**Example output record:**

```json
{
    "type": "finetune",
    "messages": [
        { "role": "system", "content": "You are analyzing a Reddit discussion. Summarize the key viewpoints from the community." },
        { "role": "user", "content": "r/MachineLearning — What's the best approach for few-shot learning in 2026?\n\nI'm building a text classifier with only 50 labeled examples per class..." },
        { "role": "assistant", "content": "1. [user_a, score: 0] Try SetFit — it fine-tunes sentence transformers on just a handful of examples and outperforms GPT-3 prompting on most benchmarks.\n2. [user_b, score: 0] LLM + chain-of-thought prompting with 5-10 examples can match full fine-tuning for classification tasks, especially with GPT-4o..." }
    ],
    "metadata": {
        "postId": "abc123",
        "subreddit": "MachineLearning",
        "score": 0,
        "upvoteRatio": 0,
        ...
    }
}
```

**Use cases**: fine-tuning domain-specific chatbots, building Q\&A models on niche topics, creating instruction-tuning datasets from community knowledge.

#### Format: `rag-markdown` — RAG pipeline / vector DB ingestion

Each output record is a self-contained markdown document combining the post and its top comments. Optimized for chunking and embedding into vector databases like Pinecone, Weaviate, Chroma, or Qdrant.

- **markdown field**: full document ready for embedding — title, post body, metadata header, and available comments with author metadata as H3 sections (the comments section is omitted when none are available)
- **chunkId**: stable identifier (`reddit-{subreddit}-{postId}`) for deduplication and upserts
- **metadata object**: all filterable attributes (subreddit, best-effort score, date, URL, domain, flair, NSFW flag) as flat fields for metadata filtering in vector DBs

**Example input:**

```json
{
    "searchQuery": "LLM fine-tuning best practices",
    "maxPostsPerSource": 200,
    "includeComments": true,
    "maxCommentsPerPost": 10,
    "commentDepth": 1,
    "outputFormat": "rag-markdown"
}
```

**Example output record:**

```json
{
    "type": "rag-chunk",
    "chunkId": "reddit-MachineLearning-abc123",
    "markdown": "# What's the best approach for few-shot learning in 2026?\n\n**Subreddit:** r/MachineLearning  \n**Author:** u/researcher42  \n**Score:** 0 (vote data unavailable)  \n...\n\n## Top Comments\n\n### u/user_a (score: 0)\n\nTry SetFit...",
    "metadata": {
        "source": "reddit",
        "subreddit": "MachineLearning",
        "postId": "abc123",
        "title": "What's the best approach for few-shot learning in 2026?",
        "score": 0,
        "upvoteRatio": 0,
        "createdAt": "2026-03-15T10:22:00.000Z",
        "url": "https://www.reddit.com/r/MachineLearning/comments/abc123/...",
        "isNSFW": false,
        ...
    }
}
```

**Use cases**: building domain-specific RAG systems, enriching knowledge bases with community knowledge, powering chatbots that answer questions from Reddit discussions.

#### Quality filtering tips for AI datasets

When building training data or RAG corpora from Reddit, filter for quality. Treat vote-based filters as optional because Reddit may omit public vote data:

- **Score threshold** — only use `metadata.score >= 50` when your run actually returns non-zero scores; otherwise prefer subreddit, keyword, and recency filters
- **Upvote ratio** — only use `metadata.upvoteRatio >= 0.85` when non-zero ratios are present; public recovery paths may return `0`
- **NSFW filter** — filter `metadata.isNSFW == false` for general-purpose datasets
- **Subreddit targeting** — scrape expert communities (r/MachineLearning, r/learnprogramming, r/personalfinance) for domain-specific knowledge
- **Time filter** — use `sort: "top"` + `timeFilter: "year"` to get the highest-quality content from the past year

### Integrations

Connect Reddit Scraper to other apps and services using [Apify integrations](https://apify.com/integrations):

📗 **Google Sheets** — automatically export Reddit posts and comments to a spreadsheet for tracking trends or building content calendars
💬 **Slack / Discord** — get notifications when scraping finishes, or set up alerts for posts matching specific keywords
⚡ **Zapier / Make** — trigger workflows based on new Reddit data, e.g., save high-engagement posts to a CRM or send weekly reports
🔔 **Webhooks** — send results to your own API endpoint for custom processing pipelines
🗓️ **Scheduled runs** — run the scraper daily or weekly to monitor subreddits for new discussions
🗄️ **Data warehouses** — pipe data to BigQuery, Snowflake, or PostgreSQL for large-scale analysis
🤖 **AI/LLM pipelines** — feed Reddit discussions into sentiment analysis, topic modeling, or lead qualification workflows

### API usage

Use the Apify API to run Reddit Scraper programmatically from your own code. Available in Python, Node.js, and any language that can call web APIs.

**Node.js:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/reddit-scraper').call({
    urls: ['https://www.reddit.com/r/technology/'],
    maxPostsPerSource: 100,
    sort: 'hot',
    includeComments: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/reddit-scraper').call(run_input={
    'urls': ['https://www.reddit.com/r/technology/'],
    'maxPostsPerSource': 100,
    'sort': 'hot',
    'includeComments': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL:**

```bash
curl "https://api.apify.com/v2/acts/automation-lab~reddit-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "urls": ["https://www.reddit.com/r/technology/"],
    "maxPostsPerSource": 100,
    "sort": "hot"
  }'
```

To retrieve results after the run completes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

### Use with AI agents via MCP

Reddit Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp). This lets you use natural language to scrape data — just ask your AI assistant and it will configure and run the scraper for you.

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/reddit-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/reddit-scraper"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Get the top 100 posts from r/technology this month"
- "Scrape comments from this Reddit thread"
- "Search Reddit for discussions about 'AI coding'"
- "Find posts mentioning our product in r/SaaS"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Diagnostic reporting

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. Batch fatal errors and exhausted batch targets are reported separately from failed Server API requests. Caller validation errors, normal empty results, and successful fallbacks are not reported as server faults. A batch still working near its deadline can send one diagnostic-only observation containing the active operation category, timing, and numeric progress counters (no URLs or input content). This observation does not mean the run failed and does not change its results or time limits.

### Legality

Scraping publicly available data from Reddit is generally considered legal. Here are the key points:

⚖️ **Public data** — Reddit Scraper only accesses publicly available posts and comments. It does not log in, bypass authentication, or access private content.

📜 **Legal precedent** — The US Ninth Circuit ruling in *hiQ Labs v. LinkedIn* (2022) established that scraping publicly available data does not violate the Computer Fraud and Abuse Act (CFAA).

🔒 **No personal data extraction** — The scraper collects usernames (which are public pseudonyms on Reddit) but does not attempt to deanonymize users or collect private information.

📋 **Terms of Service** — Reddit's ToS restricts automated access, but ToS violations are a contractual matter, not a criminal one. Many courts have ruled that ToS alone cannot make scraping illegal.

🇪🇺 **GDPR considerations** — If you scrape data that includes EU users, ensure your use case complies with GDPR. Aggregated, anonymized analysis is generally safe. Storing individual user data for profiling may require additional compliance steps.

This information is for educational purposes and does not constitute legal advice. Consult a qualified attorney for guidance specific to your use case and jurisdiction.

### FAQ

**Can I scrape any subreddit?**
Yes, as long as the subreddit is public. Private, banned and 18+-gated subreddits are reported as unavailable targets and skipped.

**Does it scrape NSFW content?**
NSFW posts that Reddit shows to logged-out visitors are included by default; filter them with the `isNSFW` field. Communities that Reddit puts behind its 18+ login gate cannot be read and are reported as unavailable.

**How many posts can I scrape?**
There is no hard limit. Set `maxPostsPerSource: 0` for unlimited. Reddit's pagination allows up to ~1,000 posts per listing. For more, use search with different time filters.

**Can I scrape comments from multiple posts at once?**
Yes. Enable `includeComments` and the scraper will fetch comments for every post it finds. Use `maxCommentsPerPost` to control how many comments per post.

**What happens if Reddit temporarily limits access?**
The actor may pause or return partial results depending on what public data is available at run time.

**Can I export to CSV or Excel?**
Yes. Apify datasets support JSON, CSV, Excel, XML, and HTML export formats. Use the dataset export buttons or API.

**The scraper returns fewer posts than I expected — what's going on?**
Reddit's pagination API has a limit of approximately 1,000 posts per listing. If you need more, use search with different time filters (e.g., `timeFilter: "month"` then `timeFilter: "year"`) to access older content. Also note that some subreddits simply have fewer posts than your limit, and a `top` listing for `day` or `week` returns only what Reddit's own top listing shows for that window, which can be empty for quiet communities.

**A subreddit is reported as unavailable — how do I fix this?**
This means Reddit shows the subreddit as private, banned, or behind its 18+ login gate, or that Reddit lists no public community with that name. Reddit shows its gate for names that do not exist too, so the Actor checks the community search before answering. The final status message gives the reason for the first skipped target, and a run where nothing could be read because of an unexpected Reddit response ends as FAILED, with nothing charged. The scraper can only access public subreddits. Check if you can view the subreddit in an incognito browser window — if not, the scraper won't be able to access it either.

**Can I use filterKeywords to narrow down search results?**
Yes. Set `filterKeywords` to an array of terms and only posts whose title or body contains at least one keyword will be kept. This is useful when Reddit's built-in search returns loosely related results.

**How do I scrape a user's post history?**
Paste the user's profile URL (e.g., `https://www.reddit.com/user/spez/`) into the URLs field. The scraper will extract their public submissions.
If Reddit says nobody goes by that username, or shows the account as deleted or banned, that target is reported as unavailable and the rest of the run continues. The same applies to a post Reddit no longer shows.

**Is there a limit on search query length?**
Yes. Reddit search accepts at most 1,024 characters per query, including any `filterKeywords` the scraper adds for you. A longer query is reported as a failed target with its length, without sending any request. Split long `OR` lists into several shorter search queries.

**Does it handle deleted or removed posts?**
Deleted posts may appear with `[deleted]` as the author and empty body text. Removed posts (mod-removed) may still show the title but have `[removed]` as the body.

### Related scrapers

- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — Scrape Instagram posts, profiles, comments, and hashtags
- [Threads Scraper](https://apify.com/automation-lab/threads-scraper) — Extract posts and profiles from Meta's Threads
- [Twitter/X Scraper](https://apify.com/automation-lab/twitter-scraper) — Extract tweets, user profiles, and search results from X
- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — Scrape TikTok videos, profiles, and trending hashtag feeds
- [Bluesky Scraper](https://apify.com/automation-lab/bluesky-scraper) — Scrape Bluesky posts, profiles, and search results
- [Social Media Profile Finder](https://apify.com/automation-lab/social-media-profile-finder) — Find social media profiles across platforms from a list of websites

### Use with AI agents via x402 (no Apify account)

Agent workflows can run this actor through Apify MCP without an Apify account when the MCP client uses a funded x402 wallet. Use the actor-specific MCP endpoint:

`https://mcp.apify.com?tools=automation-lab/reddit-scraper&payment=x402`

This keeps existing Apify MCP/API usage unchanged; x402 only changes payment/authentication for clients that support it. Learn more in Apify's [x402 integration docs](https://docs.apify.com/platform/integrations/x402).

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/reddit-scraper/changelog.md

# Actor input Schema

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

Reddit URLs to scrape. Supports subreddit URLs, post URLs, user profile URLs, and search URLs. API callers may pass either an array or a single URL string.

## `url` (type: `string`):

Optional compatibility alias for MCP/LLM tools that send a single URL instead of the canonical urls array. Prefer urls for new integrations.

## `comment_url` (type: `string`):

Optional compatibility alias for MCP/LLM tools. Use with commentContextMode=true to fetch focused context around a target comment.

## `commentUrl` (type: `string`):

Optional compatibility alias for MCP/LLM tools. Use with commentContextMode=true to fetch focused context around a target comment.

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

Search Reddit for this query. Alternative to providing URLs. Put subreddit/community names in Search subreddit; a subreddit name alone is not treated as a matching search result.

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

Run several Reddit searches in one run, for example brand names, competitors or keywords to monitor. Each query is searched separately with the same sort, time filter and post limit; duplicate posts are removed when Deduplicate Posts is on. Use together with or instead of Reddit search query.

## `searchSubreddit` (type: `string`):

Limit Reddit search to one subreddit. Enter the name with or without r/ (for example: technology or r/apify). Leave empty to search all Reddit.

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

Sort order for subreddit listings and search results.

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

Time range filter (used with 'top' and 'relevance' sort).

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

Maximum number of posts to scrape per subreddit, search, or user profile. Set 0 for unlimited posts.

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

Scrape available comments for each post using bounded public comment-tree and reply expansion. Increases runtime and proxy cost; complete coverage is not guaranteed.

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

Maximum distinct available comments returned per post after depth filtering. This is an output cap, not Reddit's total or a coverage guarantee; deadlines and public access can return fewer.

## `commentDepth` (type: `integer`):

Maximum known reply levels returned: 1 includes top-level depth 0; 10 includes known depths 0 through 9. Public subthread expansion is bounded. Comments whose depth cannot be established are retained with depth=-1, not relabeled as top-level.

## `commentContextMode` (type: `boolean`):

When enabled and a Reddit comment URL is provided, mark the target comment among the post's available public comments instead of treating the URL as a generic post URL. Default behavior stays unchanged when disabled.

## `commentContextDepth` (type: `integer`):

Kept for compatibility; the available comment tree is returned and the target comment is flagged.

## `filterKeywords` (type: `array`):

Only keep posts matching these keywords (case-insensitive). Leave empty to keep all posts. Useful when Reddit search returns loosely related results.

## `filterKeywordMode` (type: `string`):

How keywords are matched: 'any' = post title or body contains any keyword; 'titleOnly' = only match against post title (strict); 'all' = title or body must contain ALL keywords; 'exactPhrase' = title must contain the exact phrase.

## `deduplicatePosts` (type: `boolean`):

Remove duplicate posts that appear in multiple sources or pages. Enabled by default.

## `outputFormat` (type: `string`):

Controls the shape of output records. 'default' = standard post/comment objects (backward-compatible). 'jsonl-finetune' = instruction/response pairs for LLM supervised fine-tuning (SFT). 'rag-markdown' = markdown chunks with metadata for vector DB / RAG ingestion.

## `mcpDestinationConnector` (type: `string`):

Batch-run opt-in to send a summary after dataset output is saved. Requires an exact supported mcpDestinationToolName and mcpDestinationTarget. Only explicitly non-destructive messaging tools with the documented string-only schema are supported; compatibility with any particular third-party service is not guaranteed. Failure leaves the full dataset available.

## `mcpDestinationToolName` (type: `string`):

Required when a connector is selected: exactly send_message or post_message. The tool must explicitly annotate destructiveHint=false and must not be read-only. Unknown, unannotated or destructive tools are refused without calls; there is no fallback.

## `mcpDestinationTarget` (type: `string`):

Required for export: a nonempty destination identifier, at most 256 UTF-8 bytes with no control characters. The selected tool must require text and exactly one string field named channel, channel_id, destination or target. No page/database/create operations or implicit destinations are supported.

## `mcpExportMaxItems` (type: `integer`):

Maximum sampled dataset records in the batch connector summary (1–25, default 10); the entire summary is also capped at 8192 UTF-8 bytes and may be truncated earlier. Full dataset output and billing are unchanged. Ignored without connector opt-in and by Standby endpoints.

## Actor input object example

```json
{
  "urls": [
    "https://www.reddit.com/r/technology/"
  ],
  "searchQuery": "web scraping tools",
  "sort": "hot",
  "timeFilter": "week",
  "maxPostsPerSource": 3,
  "includeComments": false,
  "maxCommentsPerPost": 10,
  "commentDepth": 3,
  "commentContextMode": false,
  "commentContextDepth": 3,
  "filterKeywords": [],
  "filterKeywordMode": "any",
  "deduplicatePosts": true,
  "outputFormat": "default",
  "mcpExportMaxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

AI-readable overview of the Reddit records returned by this run.

# 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 = {
    "urls": [
        "https://www.reddit.com/r/technology/"
    ],
    "searchQuery": "web scraping tools",
    "maxPostsPerSource": 3,
    "maxCommentsPerPost": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "urls": ["https://www.reddit.com/r/technology/"],
    "searchQuery": "web scraping tools",
    "maxPostsPerSource": 3,
    "maxCommentsPerPost": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "urls": [
    "https://www.reddit.com/r/technology/"
  ],
  "searchQuery": "web scraping tools",
  "maxPostsPerSource": 3,
  "maxCommentsPerPost": 10
}' |
apify call automation-lab/reddit-scraper --silent --output-dataset

```

## MCP server setup

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