Reddit Scraper

Reddit data actor for posts, comments, users, and subreddits.

Use this actor to collect Reddit data in clean JSON format through Apify datasets.

Pricing

• Pricing: $1.25 / 1,000 results

What It Can Do

• Search Reddit posts by query
• Search subreddits by query
• Fetch posts from a subreddit
• Fetch subreddit metadata
• Fetch comments for a post
• Fetch user profile data
• Fetch posts by a user
• Fetch comments by a user
• Fetch popular posts

Why Use This Actor

• Faster than browser-based Reddit actors
• Clean dataset output for apps, agents, and workflows
• No Reddit login required
• Good fit for Python scripts, Make, n8n, and Apify workflows
• Cheaper launch pricing than many comparable Reddit actors

Input

The actor requires an action plus action-specific fields.

Supported Actions

Action	Required fields	Optional fields
search_posts	query	subreddit, sort, time, cursor
search_subreddits	query	cursor
subreddit_posts	subreddit	sort, time, cursor
subreddit_about	subreddit	none
post_comments	post_id, subreddit	sort
user_about	username	none
user_posts	username	sort, cursor
user_comments	username	sort, cursor
popular_posts	none	sort, cursor

Example Input

{
  "action": "search_posts",
  "query": "python web framework",
  "subreddit": "python",
  "sort": "top",
  "time": "month"
}

Input Examples and Usage

The examples below use a small Python wrapper so each actor action can be called with explicit parameters and sensible defaults.

from apify_client import ApifyClient


APIFY_TOKEN = "YOUR_APIFY_TOKEN"
ACTOR_ID = "good-apis/reddit-scraper"


class RedditScraperActor:
    def __init__(self, token: str, actor_id: str = ACTOR_ID) -> None:
        self.client = ApifyClient(token)
        self.actor_id = actor_id

    def _run(self, **run_input):
        run = self.client.actor(self.actor_id).call(run_input=run_input)
        return list(self.client.dataset(run["defaultDatasetId"]).iterate_items())

    def search_posts(
        self,
        query: str,
        subreddit: str | None = None,
        sort: str | None = None,
        time: str | None = None,
        cursor: str | None = None,
    ):
        return self._run(
            action="search_posts",
            query=query,
            subreddit=subreddit,
            sort=sort,
            time=time,
            cursor=cursor,
        )

    def search_subreddits(self, query: str, cursor: str | None = None):
        return self._run(action="search_subreddits", query=query, cursor=cursor)

    def subreddit_posts(
        self,
        subreddit: str,
        sort: str | None = None,
        time: str | None = None,
        cursor: str | None = None,
    ):
        return self._run(
            action="subreddit_posts",
            subreddit=subreddit,
            sort=sort,
            time=time,
            cursor=cursor,
        )

    def subreddit_about(self, subreddit: str):
        return self._run(action="subreddit_about", subreddit=subreddit)

    def post_comments(
        self,
        post_id: str,
        subreddit: str,
        sort: str | None = None,
    ):
        return self._run(
            action="post_comments",
            post_id=post_id,
            subreddit=subreddit,
            sort=sort,
        )

    def user_about(self, username: str):
        return self._run(action="user_about", username=username)

    def user_posts(
        self,
        username: str,
        sort: str | None = None,
        cursor: str | None = None,
    ):
        return self._run(action="user_posts", username=username, sort=sort, cursor=cursor)

    def user_comments(
        self,
        username: str,
        sort: str | None = None,
        cursor: str | None = None,
    ):
        return self._run(action="user_comments", username=username, sort=sort, cursor=cursor)

    def popular_posts(self, sort: str | None = None, cursor: str | None = None):
        return self._run(action="popular_posts", sort=sort, cursor=cursor)


reddit = RedditScraperActor(APIFY_TOKEN)

search_posts

items = reddit.search_posts(
    query="python web framework",
    subreddit="python",
    sort="top",
    time="month",
    cursor=None,
)
print(items)

search_subreddits

items = reddit.search_subreddits(
    query="machine learning",
    cursor=None,
)
print(items)

subreddit_posts

items = reddit.subreddit_posts(
    subreddit="python",
    sort="hot",
    time="day",
    cursor=None,
)
print(items)

subreddit_about

items = reddit.subreddit_about(subreddit="python")
print(items)

post_comments

items = reddit.post_comments(
    post_id="1r82a0a",
    subreddit="python",
    sort="top",
)
print(items)

user_about

items = reddit.user_about(username="spez")
print(items)

user_posts

items = reddit.user_posts(
    username="spez",
    sort="new",
    cursor=None,
)
print(items)

user_comments

items = reddit.user_comments(
    username="spez",
    sort="top",
    cursor=None,
)
print(items)

popular_posts

items = reddit.popular_posts(
    sort="hot",
    cursor=None,
)
print(items)

Output

Results are written to the default Apify dataset.

• list responses are pushed as one dataset item per result
• object responses are pushed as a single dataset item
• failed runs push an error object before failing

List results include:

• _action: the executed action
• _cursor: the next-page cursor when available

Client Examples

Python

See ./examples/python_client.py for the same helper wrapper in a runnable file.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('good-apis/reddit-scraper').call({
  action: 'search_posts',
  query: 'python web framework',
  subreddit: 'python',
  sort: 'top',
  time: 'month',
});

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

Agent-Friendly Notes

This actor is designed to be easy for agents to call reliably.

• Inputs are flat and structured
• actions are explicit and predictable
• pagination state is returned as _cursor
• errors fail the run explicitly instead of silently returning partial success
• dataset output is machine-readable JSON without browser rendering artifacts

For agent use, prefer:

• subreddit_about for metadata lookup
• search_posts for query-driven discovery
• post_comments for thread extraction
• _cursor chaining for pagination