# Reddit Search Scraper: Keyword & Subreddit Posts (`xmolodtsov/reddit-scraper`) Actor

Search Reddit by keyword, subreddit or author and get full post data: title, text, upvotes, comment count, author, flair, images and video. Run hundreds of searches in one job and tag every result with your own ID. No login or API key. Pay-per-result pricing from 17 Oct 2026.

- **URL**: https://apify.com/xmolodtsov/reddit-scraper.md
- **Developed by:** [GoFetch](https://apify.com/xmolodtsov) (community)
- **Categories:** Social media, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 20 total users, 13 monthly users, 93.6% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 reddit posts

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 Search Scraper: Keyword & Subreddit Posts logo](https://api.apify.com/v2/key-value-stores/2DxCOvbMjhvK3S1qP/records/reddit-scraper-avatar-128)

Reddit Search Scraper finds keyword & subreddit posts on Reddit, plus any author's posts, and returns post data: title, text, upvotes, comment count, author, subreddit, flair, images and video links. Put as many searches as you need into one run and tag each one with your own ID (`profileUrl`). Every result comes back labelled with the brand, person or topic it belongs to, ready to export as JSON, CSV or Excel or to pull through the Apify API.

It runs Reddit's own search over plain HTTP. There's no browser, no Reddit login and no API key. Requests go through the Apify residential proxy, preconfigured, so there's nothing to set up.

### Use cases

- **Brand monitoring for many clients:** an agency keeps one daily task with a search per client brand, each tagged with the client's CRM URL as `profileUrl`. With `sort: "new"` and `searchTime: "day"`, every new mention arrives already attached to the right client.
- **Product and market research:** a product team runs `subreddit:` searches in the communities its users read, sorted by `top` over the past year, and reviews the highest-voted complaints and feature requests in a spreadsheet.
- **Leads and pain points:** a SaaS founder searches phrases such as `"looking for a tool"` or `"alternative to"` for their category and gets a daily list of posts where people ask for a recommendation.
- **Social listening and research datasets:** analysts follow tickers, coins, campaigns or public figures, or collect a year of public posts on a topic, splitting busy searches per subreddit to get past Reddit's ~250-post cap.

### Why use this Reddit scraper?

- **Hundreds of searches in one run.** Each search carries your own `profileUrl`, so a single job can monitor hundreds of brands or people and send every post back to the right record.
- **Light.** In a public-page fallback test at 256 MB, seven searches returned 219 complete posts in about 4.1 minutes, with peak memory around 98 MB.
- **Tested on the Apify residential proxy.** In that test every search completed, with votes and comment counts on all 820 posts. The proxy is preconfigured.
- **Pay only per result.** From 17 October 2026, platform usage and proxy are included, with no start fee and no extra events.
- **Clear run outcomes.** A blocked run fails with a machine-readable code instead of quietly returning an empty dataset.

### What data you get

Each Reddit post is one flat dataset item with these 18 fields:

| Field             | Type            | Description                                                                            |
| ----------------- | --------------- | -------------------------------------------------------------------------------------- |
| `profileUrl`      | string          | Your ID from the search that found this post                                           |
| `id`              | string          | Reddit post ID, `t3_…`                                                                 |
| `dataType`        | string          | Always `"post"`                                                                        |
| `title`           | string          | Post title                                                                             |
| `url`             | string          | Link to the post, `https://www.reddit.com/r/…/comments/…`                              |
| `createdAt`       | string          | Creation time in ISO 8601, UTC                                                         |
| `upVotes`         | integer or null | Post score (upvotes), or `null` when unknown                                           |
| `numberOfreplies` | integer or null | Number of comments on the post, or `null` when unknown                                 |
| `communityName`   | string          | Subreddit, as `r/name`                                                                 |
| `username`        | string          | Author's username, or `[deleted]` when the account no longer exists                    |
| `body`            | string or null  | Post text, or `null` for link, image and video posts without text                      |
| `userId`          | string or null  | Author's ID, `t2_…`, or `null`                                                         |
| `flair`           | string or null  | Post flair                                                                             |
| `thumbnailUrl`    | string or null  | Thumbnail image URL                                                                    |
| `imageUrls`       | array           | Direct and gallery image URLs, or empty. Link and video post previews aren't included. |
| `videoUrl`        | string or null  | Reddit-hosted video URL (`null` for YouTube and other embedded videos)                 |
| `isVideo`         | boolean         | `true` for Reddit-hosted video posts                                                   |
| `isNSFW`          | boolean or null | `true` when Reddit flags the post as adult, or `null` when unknown                     |

Only the comment count is collected, not the comments themselves.

### How to use Reddit Search Scraper

#### In Apify Console

1. Open [Reddit Search Scraper](https://apify.com/xmolodtsov/reddit-scraper) in Apify Store and click **Try for free**.
2. In **Search Queries**, add one `{ "profileUrl", "searchQuery" }` pair per search. `profileUrl` is your own label, and `searchQuery` is what Reddit should search for. Reddit's search operators work here (see [Reddit search operators](#reddit-search-operators)).
3. Pick a **Time Filter** and **Sort Order**, and set **Results Per Query** (25 by default). Leave the proxy settings as they are.
4. Click **Start**. Posts are saved to the dataset as soon as they're found.
5. Open the **Output** tab and download the posts as JSON, CSV, Excel, XML or HTML, or read them through the API.

#### From the API

The Actor's ID for the API, clients and agents is `xmolodtsov/reddit-scraper`. Run it and get the posts back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/xmolodtsov~reddit-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":[{"profileUrl":"brand:acme","searchQuery":"\"Acme shoes\""}],"searchTime":"day","maxItemsPerQuery":50}'
```

JavaScript and Python examples are under [Integrations and API](#integrations-and-api).

#### From an AI agent (MCP)

Add the Actor to any MCP client (Claude, Cursor, VS Code and others) through Apify's MCP server:

```
https://mcp.apify.com?tools=xmolodtsov/reddit-scraper
```

Your agent can then call it with the input below, for example "find this week's posts in r/personalfinance about credit card fees". The usual pricing and free-plan limits apply.

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

From **17 October 2026 (15:00 UTC)**, Reddit Search Scraper is priced **pay per result**. You pay only for posts saved to the dataset. Platform usage and the residential proxy are included, and there's no start fee and no extra events. The price per 1,000 posts depends on your Apify plan:

| Apify plan           | Price per 1,000 posts |
| -------------------- | --------------------- |
| Free                 | $2.00                 |
| Starter (Bronze)     | $1.90                 |
| Scale (Silver)       | $1.80                 |
| Business (Gold)      | $1.75                 |
| Platinum and Diamond | $1.75 (Gold price)    |

Examples on a Starter plan:

- 1,000 posts cost **$1.90**.
- Monitoring 50 brands daily at 20 new posts each comes to about 30,000 posts a month, or about **$57**. On a Business plan, that's about **$52.50**.

#### Is it free?

**Until 17 October 2026 (15:00 UTC)**, the Actor itself is free. You pay only the Apify platform usage of your own runs (compute and residential proxy), which is billed by Apify.

On the **Apify Free plan**, this Actor allows:

- up to **100 results per run**, and
- **20 runs per calendar month** per account.

These limits are **set by the developer, not by Apify**, and they apply both before and after 17 October 2026. Any paid Apify plan removes them. A run that hits a limit ends successfully, with a status message explaining the limit. The monthly count resets on the 1st.

### Input

| Field                   | Type    | Default           | Description                                                                                                             |
| ----------------------- | ------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `queries`               | array   | required          | The searches to run. Each item is `{ "profileUrl": "...", "searchQuery": "..." }`.                                      |
| `queries[].profileUrl`  | string  | required          | Your own ID for this search. It can be any string and is usually a URL. It's copied into every result from this search. |
| `queries[].searchQuery` | string  | required          | What to search on Reddit. Supports quotes, `OR`, `subreddit:name` and `author:name`.                                    |
| `searchTime`            | string  | `all`             | Time filter: `hour`, `day`, `week`, `month`, `year` or `all`.                                                           |
| `sort`                  | string  | `new`             | Sort order: `new`, `relevance`, `hot`, `top` or `comments`.                                                             |
| `includeNSFW`           | boolean | `true`            | Set to `false` to leave out posts that Reddit flags as adult.                                                           |
| `searchMode`            | string  | `raw`             | How multi-word searches are combined: `raw`, `exact`, `and` or `or` (see below).                                        |
| `searchType`            | string  | `posts`           | `posts` applies Reddit's posts-only filter, while `all` searches without it. The output is always posts.                |
| `maxItemsPerQuery`      | integer | `25`              | Maximum posts per search, from 1 to 500. Reddit's search stops at about 250 posts per search.                           |
| `maxItems`              | integer | none              | Global cap on posts across all searches. Useful for budget control. On the Apify Free plan, it's capped at 100.         |
| `maxConcurrency`        | integer | `3`               | How many searches run at the same time, from 1 to 5.                                                                    |
| `proxyConfiguration`    | object  | Apify residential | The default is preconfigured and is what the Actor is tested on.                                                        |

#### Search modes

| Mode    | You enter      | Reddit searches for | Use it for                                |
| ------- | -------------- | ------------------- | ----------------------------------------- |
| `raw`   | `Emily Miller` | `Emily Miller`      | Reddit's default behavior                 |
| `exact` | `Emily Miller` | `"Emily Miller"`    | Exact phrases, person names and usernames |
| `and`   | `Emily Miller` | `Emily AND Miller`  | All words must appear                     |
| `or`    | `Taylor Swift` | `Taylor OR Swift`   | Any of the words                          |

Field operators such as `author:name` and `subreddit:name` stay as written in every mode; only the other words are quoted or joined. In `exact` mode, `subreddit:personalfinance credit card` becomes `subreddit:personalfinance "credit card"` and `author:example_user` stays `author:example_user`.

If a `searchQuery` already contains `AND`, `OR` or `NOT`, or is wrapped in quotes, it's sent exactly as written, whatever the mode.

#### Input example

The minimal input is one search:

```json
{
    "queries": [{ "profileUrl": "brand:acme", "searchQuery": "acme" }]
}
```

A fuller example with three searches, each routed to its own record:

```json
{
    "queries": [
        { "profileUrl": "https://myapp.com/brands/acme", "searchQuery": "\"Acme shoes\" OR \"Acme running\"" },
        { "profileUrl": "https://myapp.com/brands/acme-runners", "searchQuery": "subreddit:running acme" },
        { "profileUrl": "https://myapp.com/people/example-user", "searchQuery": "author:example_user" }
    ],
    "searchTime": "week",
    "sort": "new",
    "maxItemsPerQuery": 100,
    "maxItems": 1000
}
```

#### Reddit search operators

- `"exact phrase"` matches the words in that order, such as `"Acme running shoes"`.
- `OR` matches any alternative, such as `acme OR globex`.
- `subreddit:name` searches one community, such as `subreddit:personalfinance credit card`.
- `author:name` returns one user's posts, such as `author:example_user`.

You can combine operators, for example `subreddit:investing "index fund" OR ETF`.

#### Work around the ~250-post cap

Reddit's search stops at about 250 posts per search, so raising `maxItemsPerQuery` above that won't return more. For busy topics, run more often with a shorter time filter, such as `day` or `hour` instead of `month`. You can also split one broad search into narrower ones, for example one per subreddit.

### Output

Here are 8 posts from a real run with 12 keyword searches (sort `relevance`, past year), shown in a table:

![Reddit Search Scraper output: Reddit posts with search, title, subreddit, score, comment count and date from a real run](https://api.apify.com/v2/key-value-stores/2DxCOvbMjhvK3S1qP/records/reddit-scraper-output-table.png)

Each post is saved as one dataset item. The values below are illustrative; the field names and types are exactly what you get:

```json
{
    "profileUrl": "https://myapp.com/brands/acme",
    "id": "t3_1abc234",
    "dataType": "post",
    "title": "Has anyone tried the new Acme running shoes?",
    "url": "https://www.reddit.com/r/running/comments/1abc234/has_anyone_tried_the_new_acme_running_shoes/",
    "createdAt": "2026-10-02T14:31:07.000Z",
    "upVotes": 128,
    "numberOfreplies": 47,
    "communityName": "r/running",
    "username": "trail_miles",
    "body": "Thinking about switching for marathon training. How do they hold up?",
    "userId": "t2_8f3k1x9z",
    "flair": "Gear",
    "thumbnailUrl": "https://b.thumbs.redditmedia.com/abc123.jpg",
    "imageUrls": ["https://preview.redd.it/abc123.jpeg?auto=webp&s=0f1e2d"],
    "videoUrl": null,
    "isVideo": false,
    "isNSFW": false
}
```

Field names are case-sensitive and stay stable, so existing pipelines don't break (see [What data you get](#what-data-you-get) for every field). The **Overview** tab in Console shows `profileUrl`, `title`, `url`, `communityName`, `createdAt` and `upVotes`; the full item has every field.

### When does a run succeed or fail?

- A run that saved any posts **succeeds**, even if some searches failed or an error happened afterwards. Posts already collected are never thrown away.
- A run that saved no posts, where every search got a valid answer from Reddit, also **succeeds**. Its status message starts with `empty`: nothing matched.
- A run that saved no posts, where at least one search never got a valid answer, ends **FAILED**. Its status message starts with the most common cause, such as `blocked`, `challenge`, `network` or `rate_limited`, so an integration can recognize the failure and retry.
- Each results page gets several attempts, each on a fresh Reddit session, with growing waits between them, so a brief rejection only slows the run. If Reddit keeps blocking every request, the run fails within about 4–6 minutes.
- When Reddit's rate limit is reached, the run waits for it to reset instead of failing.
- A post never appears twice within one search. If two searches with different `profileUrl` values match the same post, each gets its own copy.
- If the platform moves a run to another server, it resumes and skips the searches that already finished.

Every run also writes two records to its default key-value store:

- `STATISTICS` holds per-run counters: searches processed, succeeded, failed, partial and skipped, total posts saved and run duration.
- `QUERY_RESULTS` holds one entry per search with its `profileUrl`, `searchQuery`, `status` (`success`, `partial`, `failed` or `skipped`), `postsFound`, `postsSaved` and any error.

### Integrations and API

#### JavaScript and Python clients

For large batches, start an asynchronous run and read the dataset when it finishes. With the JavaScript client:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('xmolodtsov/reddit-scraper').call({
    queries: [
        { profileUrl: 'brand:acme', searchQuery: '"Acme shoes"' },
        { profileUrl: 'brand:globex', searchQuery: 'subreddit:running globex' },
    ],
    searchTime: 'day',
    maxItemsPerQuery: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

With the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")
run = client.actor("xmolodtsov/reddit-scraper").call(
    run_input={"queries": [{"profileUrl": "brand:acme", "searchQuery": "\"Acme shoes\""}]},
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

#### Schedules and webhooks

For ongoing monitoring, save your input as a task and give it an [Apify schedule](https://docs.apify.com/platform/schedules). Match the time filter to the schedule: use `searchTime: "day"` with `sort: "new"` for a daily run, or `searchTime: "hour"` for an hourly one on fast-moving topics. Time windows can overlap slightly between runs, so deduplicate downstream on `profileUrl` plus `id`, and keep each `profileUrl` stable from run to run.

Use **webhooks** to notify your system when a run succeeds or fails. A failed run's status message starts with a code such as `blocked` or `rate_limited`, which you can use to decide whether to retry.

#### Make, Zapier and n8n

Apify's [integrations](https://docs.apify.com/platform/integrations) for Make, Zapier and n8n can start this Actor and pass the posts on to Google Sheets, Slack, a CRM or your database without any code.

### More scrapers from this developer

**TikTok:** [TikTok Search Scraper](https://apify.com/xmolodtsov/tiktok-search-scraper): videos and creators for any keyword, pay per result · [TikTok Profile Scraper (Pay Per Result)](https://apify.com/xmolodtsov/tiktok-profile-scraper): profiles, followers and latest posts by username · [TikTok Comments Scraper](https://apify.com/xmolodtsov/tiktok-comments-scraper): comments and full reply threads from any video · [TikTok Hashtag Scraper](https://apify.com/xmolodtsov/tiktok-hashtag-scraper): videos for any hashtag, with views, likes and music · [TikTok Sound & Music Scraper](https://apify.com/xmolodtsov/tiktok-sound-scraper): videos that use a sound or song · [TikTok Top Ads Scraper](https://apify.com/xmolodtsov/tiktok-top-ads-scraper): public Creative Center ad rankings, engagement, media and landing pages

**Social & news:** [Google News Scraper](https://apify.com/xmolodtsov/google-news-scraper): Google News results as clean full-text articles · [Threads Replies Scraper](https://apify.com/xmolodtsov/threads-replies-scraper): public post replies, likes, authors and inline nested replies

**Instagram:** [Instagram Reel Scraper](https://apify.com/xmolodtsov/instagram-reel-scraper): public profile reels, plays, captions, music and media URLs · [Instagram Comment Scraper](https://apify.com/xmolodtsov/instagram-comment-scraper): public post and reel comments, likes, timestamps and usernames

**E-commerce:** [Prom.ua Product Search Scraper](https://apify.com/xmolodtsov/prom-ua): Prom.ua product search results, no browser needed · [Amazon Product Search & Bestsellers Scraper](https://apify.com/xmolodtsov/amazon-search-scraper): search results, Best Sellers and product details from Amazon · [AliExpress Search Scraper](https://apify.com/xmolodtsov/aliexpress-search-scraper): aliExpress products by keyword with prices, orders and shipping · [AliExpress Product Reviews Scraper](https://apify.com/xmolodtsov/aliexpress-reviews-scraper): public product reviews, ratings, buyer photos and follow-up feedback

**Maps & leads:** [Google Maps Scraper](https://apify.com/xmolodtsov/google-maps-scraper): places, leads and emails from Google Maps

**Ads:** [Facebook Ad Library Scraper (Meta Ads Library)](https://apify.com/xmolodtsov/facebook-ads-library-scraper): ads from the Meta Ad Library, with EU reach and payers · [Google Ads Transparency Scraper](https://apify.com/xmolodtsov/google-ads-transparency-scraper): Google ad creatives by advertiser or domain, with regional details

**Video:** [YouTube Transcript Scraper](https://apify.com/xmolodtsov/youtube-transcript-scraper): transcripts, subtitles and captions from YouTube videos · [YouTube Shorts Scraper](https://apify.com/xmolodtsov/youtube-shorts-scraper): Shorts of any channel with exact views, likes and duration · [YouTube Channel Scraper](https://apify.com/xmolodtsov/youtube-channel-scraper): every video of a channel, with channel stats · [YouTube Search Scraper](https://apify.com/xmolodtsov/youtube-search-scraper): search results and videos for any keyword · [YouTube Comments Scraper](https://apify.com/xmolodtsov/youtube-comments-scraper): comments, replies and likes from any video · [Bilibili Comments Scraper](https://apify.com/xmolodtsov/bilibili-comments-scraper): public hot comments and reply threads by video or keyword

**Jobs:** [SEEK Job Listings Scraper](https://apify.com/xmolodtsov/seek-jobs-scraper): public AU/NZ job listings, salaries and redacted descriptions

### FAQ

#### Is it legal to scrape Reddit?

This Actor collects only posts that are publicly visible on Reddit, and it does so without logging in. It never collects private or deleted content.

Results can include Reddit usernames and user IDs, which are personal data. Laws such as the GDPR and the CCPA may therefore apply to how you store and use them. You're responsible for using the data lawfully and in line with Reddit's terms. Collect only what you need, and keep it secure.

For background, read Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/). This is general information, not legal advice.

#### Do I need a Reddit account, login or API key?

No. The Actor uses Reddit's public search without logging in. You only need an Apify account.

#### Does it scrape comments?

No. You get each post's comment count in `numberOfreplies`, but not the comments themselves.

#### What happens when Reddit limits post details?

The Actor prefers Reddit's JSON search. When that is blocked, it uses the public search feed with batched post details. If Reddit also forbids the feed, public HTML search discovers posts and each post's public page supplies its full body, flair, author ID, counts, images and hosted-video link. HTML search can rank and limit results differently from the feed.

Search discovery includes ordinary cards and grouped crosspost results, preserving the matching primary post rather than unrelated sibling communities. Post-page enrichment gets two attempts per post, plus one fresh-session attempt after network or proxy 5xx failures, and continues until the requested number of saved posts or the available results are exhausted. It has no fixed request-count budget; repeated cursors, 100 pages, 30 minutes per query, and five consecutive post transport failures bound the work. Confirmed deleted/removed posts and explicit private-community or age-gate interstitials are skipped and recorded in `UNAVAILABLE_POSTS_<query index>` without making the query partial; later results fill their places. A post whose details still cannot be read is excluded from the main dataset and recorded in `INCOMPLETE_POSTS_<query index>` in the run's key-value store, with `enrichmentStatus: "failed"` and an error. Validation errors name the missing fields, post type and page markers. `QUERY_RESULTS` reports affected queries as partial or failed. A run with some complete results succeeds; a run with only enrichment failures fails with `details`. Incomplete rows are never charged as results or emitted with an apparently empty body. Every advertised self-text container must parse. Title-only text posts and outbound-link preview excerpts do not require self-text. Each gallery item uses its original image or its own preview; an unreadable item is incomplete. Thumbnails can use original gallery/image assets when previews are absent, and hosted video detection includes Reddit CDN subdomains such as `cf.v.redd.it`. Video URLs use the canonical `https://v.redd.it/<id>/CMAF_<height>.mp4?source=fallback` form regardless of the manifest host. Missing detail fields preserve known search-card values; an author unknown in both sources is quarantined, while explicitly deleted authors remain `[deleted]`. Pagination stops on any repeated cursor and has a hard limit of 100 pages per query. Main dataset fields and types stay unchanged; a genuinely absent body or flair is still `null`.

As before the November incident, the public-page fallback does not guarantee external-video embed URLs or the original JSON preview-image sources for link/video posts. No account or login wall is used.

#### Why did a search return fewer posts than I asked for?

Reddit's search stops at about 250 posts per search, and a narrow time filter may hold fewer matching posts than your limit. Turning off `includeNSFW`, setting a global `maxItems` or running on the Apify Free plan also reduces the count. The `QUERY_RESULTS` record shows exactly how many posts each search found and saved.

#### My run returned no posts or failed. What should I do?

If the run succeeded with an `empty` status, Reddit answered but nothing matched. Try a broader search, a longer time filter or `searchMode: "raw"`. If the run failed with a code such as `blocked`, `network` or `rate_limited`, no posts were saved and at least one search couldn't get through, so retry the run. Check `QUERY_RESULTS` to see which searches were affected.

#### Can I get the newest posts from one subreddit or one user?

Yes. Use `subreddit:name` as the whole search query with `sort: "new"` to list a community's newest posts, or `author:name` to get one user's posts.

#### Can I use my own proxy?

You can change `proxyConfiguration`, but the default Apify residential proxy is preconfigured and is what the Actor is tested on. Reddit blocks most datacenter IPs.

#### Is `numberOfreplies` a typo?

The lowercase "r" is intentional and stays stable for existing integrations. Field names are case-sensitive, so use it exactly as written.

#### My integration still sends `fastMode`. Will it break?

No. Old integrations that send `fastMode` keep working. The setting no longer has any effect, and every run returns full post data.

### Support

Found a bug, or need a field or feature? Open an issue on the Actor's **Issues** tab in Apify Store. Include the run ID and, for a failed run, the code its status message starts with. That's usually enough to find the cause.

# Changelog

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

# Actor input Schema

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

One or more Reddit searches, as <code>\[{"profileUrl": "any-id", "searchQuery": "keyword"}]</code>. <code>searchQuery</code> takes Reddit search syntax: "exact phrase", OR, <code>subreddit:name</code>, <code>author:name</code>. <code>profileUrl</code> is your own label (any string, usually a URL), copied into every post the search returns.<br><br>Batch hundreds of searches in one run. Posts per search are set by <code>maxItemsPerQuery</code> (default 25; Reddit stops at about 250), the run total by <code>maxItems</code>.

## `searchTime` (type: `string`):

Filter posts by how recently they were created. Use <strong>Past Week</strong> for fresh content or <strong>All Time</strong> for comprehensive results.

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

How to sort search results. <strong>Newest</strong> for recent posts, <strong>Top</strong> for highest engagement, <strong>Most Relevant</strong> for best keyword match.

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

Include adult (NSFW) content. When disabled, posts Reddit flags as adult are filtered out.

## `searchMode` (type: `string`):

How to combine multi-word search terms.<br><br><strong>raw</strong>: Pass as-is (Reddit default, implicit AND).<br><strong>exact</strong>: Wrap in quotes for exact phrase match. <em>Recommended for names/usernames.</em><br><strong>and</strong>: Explicit AND between words.<br><strong>or</strong>: Match any word.<br><br>Field operators such as <code>author:name</code> and <code>subreddit:name</code> stay as written in every mode; only the other words are quoted or joined.

## `searchType` (type: `string`):

Filter search results by type.<br><br><strong>posts</strong>: Only search posts (default, recommended).<br><strong>all</strong>: Search without the posts-only filter. Note: the output always contains posts only — comments and communities are never scraped.

## `maxItemsPerQuery` (type: `integer`):

Maximum posts to return for each search. Reddit's search itself stops at about 250 posts per search, so for busy topics run more often with a shorter time filter instead of raising this.<br><br><strong>Free Apify plan:</strong> at most 100 results per run in total.

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

Hard cap on total posts across all queries. Useful for budget control. Leave empty to collect all available results up to per-query limits.<br><br><strong>Free Apify plan:</strong> capped at 100.

## `fastMode` (type: `boolean`):

No longer has any effect, kept so existing integrations keep working. Every run returns full post data.

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

How many searches run at the same time. Each uses its own Reddit session. The default of 3 suits most runs.

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

Proxy settings. The default Apify residential proxy is what this Actor is tested on, and from 17 October 2026 it is included in the pay-per-result price. Reddit blocks most datacenter IPs.

## Actor input object example

```json
{
  "queries": [
    {
      "profileUrl": "https://example.com/topics/standing-desks",
      "searchQuery": "standing desk"
    },
    {
      "profileUrl": "https://example.com/topics/credit-cards",
      "searchQuery": "subreddit:personalfinance credit card"
    }
  ],
  "searchTime": "all",
  "sort": "new",
  "includeNSFW": true,
  "searchMode": "raw",
  "searchType": "posts",
  "maxItemsPerQuery": 25,
  "fastMode": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `posts` (type: `string`):

Flat list of Reddit posts — each entry is a single post with profileUrl for routing.

# 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": [
        {
            "profileUrl": "https://example.com/topics/standing-desks",
            "searchQuery": "standing desk"
        },
        {
            "profileUrl": "https://example.com/topics/credit-cards",
            "searchQuery": "subreddit:personalfinance credit card"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xmolodtsov/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": [
        {
            "profileUrl": "https://example.com/topics/standing-desks",
            "searchQuery": "standing desk",
        },
        {
            "profileUrl": "https://example.com/topics/credit-cards",
            "searchQuery": "subreddit:personalfinance credit card",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("xmolodtsov/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 '{
  "queries": [
    {
      "profileUrl": "https://example.com/topics/standing-desks",
      "searchQuery": "standing desk"
    },
    {
      "profileUrl": "https://example.com/topics/credit-cards",
      "searchQuery": "subreddit:personalfinance credit card"
    }
  ]
}' |
apify call xmolodtsov/reddit-scraper --silent --output-dataset

```

## MCP server setup

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