Pricing

from $3.99 / 1,000 results

Go to Apify Store

Reddit Posts Scraper

Try for free

Pricing

from $3.99 / 1,000 results

Rating

0.0

(0)

Developer

ScraperX

Actor stats

Bookmarked

Total users

Monthly active users

3 days ago

Last modified

Reddit Posts Scraper — Extract Posts, Comments, Scores & Media from Any Subreddit

Scrape Reddit posts and their comment threads without a browser and without a Reddit API key. Enter subreddit names, full Reddit URLs, or plain search keywords — the Actor returns structured rows with post title, author, score, comment count, body text, media links, subreddit, and a nested comment tree with replies.

Sort by Hot, New, Top or Rising, add a time window, and control exactly how many comments you pay for.

What you get

📝 Post data	💬 Comments	🔎 Run diagnostics
Post ID and permalink	Comment author	Success flag per post
Title and full body text	Comment body	Error message when a post fails
Author	Comment score	Processing time per post
Score (upvotes)	Creation timestamp	Proxy tier used
Number of comments	Nested replies
Subreddit	Configurable per-post limit
Image URL and thumbnail
Creation timestamp (UTC)

Key features

Three input types, mixed freely. Full URLs (https://www.reddit.com/r/news/), bare subreddit names (news or r/technology) and search keywords (artificial intelligence) — all in the same list. Duplicate subreddits are merged automatically.
Real comment threads, not flat lists. Comments come back with their replies nested inside them, so the shape of a discussion is preserved instead of being flattened into unrelated rows.
Comments are optional and capped. Set maxComments to 0 for a fast, cheap metadata-only pass, or up to 1,000 per post when the discussion is the point.
Four sort orders with a time window. Hot, New, Top and Rising; timeFilter (hour / day / week / month / year / all) applies to Top and Rising — and the Actor is explicit that it is ignored for Hot and New, so you are never quietly misled.
Automatic proxy fallback. Starts with no proxy, escalates to datacenter, then residential with up to 3 retries when Reddit blocks or rate-limits.
Configurable request delay to stay under Reddit's rate limits on long runs.
Nothing disappears. A post that fails is written to the dataset with success: false and a precise error_message (block, timeout, proxy error, connection failure), so a partial run is fully auditable.
No browser, no API key. Lightweight HTTP requests mean fast runs and low memory use.

Use cases

Market & audience research — find out what people genuinely say about a product, in their own words, with upvotes as a proxy for agreement.
Social listening & brand monitoring — track keyword mentions across Reddit and read the replies, not just the headline.
Content ideas & SEO — the top posts in a subreddit are a ranked list of what an audience cares about.
Sentiment analysis — post bodies plus nested comments give you a clean corpus with scores attached.
Lead generation — spot posts asking for recommendations in your category and respond where it is welcome.
Trend detection — schedule sortOrder: rising runs to catch topics while they are still accelerating.
Competitive intelligence — monitor how competitors are discussed in industry subreddits.
Academic and data-science research — build reproducible datasets of public discourse with timestamps and engagement metrics.

How it works

You list sources — subreddits, URLs and/or keywords. Duplicates are merged.
Each source is resolved: subreddits and URLs are read as listings; keywords are run as a Reddit search.
Posts are collected in your chosen sort order, up to maxPosts per source.
Comments are fetched per post up to maxComments, with replies nested inside each comment.
On a block or rate limit, the proxy tier escalates automatically and the request is retried.
Every post produces one row — successful or not — and rows stream into the dataset as they complete.

Quick start

Open the Actor and add your sources — e.g. news, r/technology, artificial intelligence.
Set Maximum posts per source (start with 20).
Set Maximum comments per post — use 0 while testing for speed.
Choose a Sort order and, for Top/Rising, a Time filter.
Click Start and export the Output tab as JSON (recommended — comments are nested) or CSV.

Minimal input

{
  "startUrls": ["https://www.reddit.com/r/news/"],
  "maxPosts": 25,
  "maxComments": 5,
  "sortOrder": "top",
  "timeFilter": "week"
}

Input configuration

Field	Type	Default	Description
`startUrls`	array	— (required)	One item per line. Mix full Reddit URLs, subreddit names (`news`, `r/news`) and search keywords. Duplicate subreddits are merged.
`maxPosts`	integer	`10`	Maximum posts per source, 1–1000. Three sources at 50 can return up to 150 posts.
`maxComments`	integer	`5`	Maximum comments per post, 0–1000. Set to `0` to skip comments entirely for a faster, cheaper run.
`sortOrder`	string	`top`	`hot` (trending now), `new` (latest first), `top` (most upvoted), `rising` (gaining traction).
`timeFilter`	string	`week`	`hour`, `day`, `week`, `month`, `year`, `all`. Only applies to `top` and `rising` — ignored for `hot` and `new`.
`proxyConfiguration`	object	off	Optional. On a block the Actor falls back automatically: no proxy → datacenter → residential. Recommended for large runs.

Output data

One row per post.

Field	Type	Description
`post_id`	string	Reddit post ID.
`title`	string	Post title.
`body`	string	Self-text body of the post.
`author`	string	Reddit username of the poster.
`subreddit`	string	Subreddit the post belongs to.
`score`	number	Net upvotes.
`num_comments`	number	Total comments Reddit reports on the post.
`permalink`	string	Reddit permalink path to the post.
`image_url`	string	External / media URL the post points to.
`thumbnail_url`	string	Thumbnail image URL.
`created_utc`	number	Creation timestamp (Unix, UTC).
`comments`	array	Comment objects: `{ author, body, score, created_utc, replies[] }`, with replies nested recursively.
`success`	boolean	Whether the post was scraped successfully.
`error_message`	string	Failure reason when `success` is `false`.
`processing_time`	number	Seconds spent on this post.

Example output

{
  "post_id": "1abcdef",
  "title": "What's the most useful automation you've built at work?",
  "body": "I built a script that reconciles two spreadsheets every morning…",
  "author": "example_user",
  "subreddit": "productivity",
  "score": 4821,
  "num_comments": 612,
  "permalink": "/r/productivity/comments/1abcdef/whats_the_most_useful_automation/",
  "image_url": "",
  "thumbnail_url": "https://b.thumbs.redditmedia.com/…",
  "created_utc": 1786451234,
  "comments": [
    {
      "author": "another_user",
      "body": "I automated invoice chasing — saved about six hours a week.",
      "score": 512,
      "created_utc": 1786454321,
      "replies": [
        {
          "author": "third_user",
          "body": "How are you handling the reminders?",
          "score": 88,
          "created_utc": 1786455000,
          "replies": []
        }
      ]
    }
  ],
  "success": true,
  "error_message": null,
  "processing_time": 1.42
}

Illustrative values — a live run returns current Reddit data.

Usage examples

Top of the week across several subreddits

{
  "startUrls": ["r/technology", "r/programming", "r/artificial"],
  "maxPosts": 50,
  "maxComments": 10,
  "sortOrder": "top",
  "timeFilter": "week"
}

Keyword monitoring across all of Reddit

{
  "startUrls": ["your brand name", "your product category"],
  "maxPosts": 100,
  "maxComments": 20,
  "sortOrder": "new"
}

Save as a Task with a daily Schedule and deduplicate on post_id for a brand-mention feed.

Catch trends early

{
  "startUrls": ["r/startups", "r/SaaS"],
  "maxPosts": 40,
  "sortOrder": "rising",
  "timeFilter": "day",
  "maxComments": 0
}

Deep discussion mining

{
  "startUrls": ["https://www.reddit.com/r/AskReddit/"],
  "maxPosts": 20,
  "maxComments": 500,
  "sortOrder": "top",
  "timeFilter": "month"
}

Fast, cheap metadata pass

{
  "startUrls": ["r/news"],
  "maxPosts": 500,
  "maxComments": 0,
  "sortOrder": "hot"
}

Run it from your own code

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("scraperx/reddit-posts-scraper").call(run_input={
    "startUrls": ["r/technology", "artificial intelligence"],
    "maxPosts": 50,
    "maxComments": 10,
    "sortOrder": "top",
    "timeFilter": "week",
})

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    if post["success"]:
        print(post["score"], "|", post["subreddit"], "|", post["title"])

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_API_TOKEN>' });

const run = await client.actor('scraperx/reddit-posts-scraper').call({
    startUrls: ['r/technology'],
    maxPosts: 50,
    maxComments: 10,
});

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

cURL

curl -X POST "https://api.apify.com/v2/acts/scraperx~reddit-posts-scraper/runs?token=<YOUR_APIFY_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":["r/technology"],"maxPosts":50,"maxComments":10}'

Integrations

Push posts to Google Sheets, Airtable, Slack, Make, Zapier, Google Drive or your own endpoint via webhooks, and use Schedules for continuous social listening.

Pricing

Pay-per-event: a small Actor-start charge plus a charge per post row delivered to your dataset. Comments travel inside the post row, so fetching more comments does not increase the row count — the cost driver is how many posts you collect.

Current rates are on the Pricing tab of this Actor's page, and Apify shows an estimate before and during every run.

Limits & good to know

maxPosts is per source. Three sources at 50 posts each can return up to 150 rows.
timeFilter only affects top and rising. With hot or new it is ignored — by Reddit, not by the Actor.
Comments cost time, not rows. High maxComments values make runs much longer; start low and raise it when you need the depth.
Reddit rate-limits aggressively. For large runs, enable Apify Proxy up front rather than waiting for the fallback to trigger.
Only public subreddits and posts are accessible. Private, quarantined and banned communities are not.
Deleted or removed content comes back as Reddit serves it ([deleted], [removed]).
Rows with success: false carry a precise error_message — re-run just those sources if needed.
Default run options are 4 GB memory and a 1-hour timeout — raise the timeout for deep comment runs.

FAQ

Do I need a Reddit account or API credentials? No. The Actor reads public Reddit data without authentication.

Can I search all of Reddit by keyword? Yes — put the keyword in startUrls as plain text and it runs as a Reddit search.

Do I get comment replies? Yes. Each comment carries a replies array containing its own child comments, recursively.

How do I make runs faster and cheaper? Set maxComments to 0. Post metadata alone is dramatically quicker.

Why is my time filter being ignored? Because sortOrder is hot or new. Reddit only applies a time window to top and rising.

Do I need a proxy? Not to start. The Actor escalates automatically on blocks, but pre-enabling Apify Proxy is recommended for anything large.

Can it scrape private subreddits? No. Only publicly accessible content.

Which export format should I use? JSON if you want the nested comment trees; CSV works well when you set maxComments: 0.

Legal & responsible use

This Actor collects only publicly available Reddit content — the same posts and comments any visitor can read without logging in. It does not log in, vote, post, or access private communities. Usernames and post content are personal data and remain the property of their authors: ensure your use complies with Reddit's User Agreement, copyright, and GDPR or comparable regulations.