Reddit Trends Scraper — Trending Subreddit & Velocity Report

Reddit Trends Scraper — Posts, Subreddit Rollups & Velocity Scores

Reddit Trends Scraper pulls posts from any subreddit, user profile, keyword search, or raw Reddit URL and returns typed JSON rows — no HTML parsing required. Each post carries a computed velocity score (upvotes per hour of post age) and engagement rate (comments per upvote), so you can rank momentum instead of raw score alone. Turn on the subreddit rollup and the Actor adds one aggregate row per community — post count, average and median velocity, top post, and live subscriber/active-user counts pulled from Reddit's own community metadata.

Unlike a scraper that hands back raw HTML for you to parse, Reddit Trends Scraper returns normalized JSON — ready for a spreadsheet, a database, or an LLM context window without a cleanup pass. This guide covers every input and output field byte-for-byte, the exact velocity formula, and how teams run it for real-time enrichment, scheduled trend monitoring, and bulk dataset builds.

What Does Reddit Trends Scraper Do?

Reddit Trends Scraper takes a list of subreddits, user profiles, full Reddit URLs, or free-text keywords and returns each matching post as a structured row, plus an optional per-subreddit rollup. It reads old.reddit.com's listing pages and each subreddit's public about.json metadata — no Reddit account, login, or API key is required anywhere in the pipeline.

• Accepts four input shapes in a single list: r/subreddit, u/username, a full reddit.com URL, or a plain keyword (routed to Reddit's search)
• Computes velocityScore (upvotes ÷ post-age-in-hours) and engagementRate (comments ÷ upvotes) per post from Reddit's exact millisecond timestamp, not an estimated age
• Supports all five of Reddit's native sort orders — hot, rising, new, top, controversial — with the top/controversial time window
• Builds an optional subreddit rollup: post count, average/median velocity, average upvotes and comments, top post, and live subscriber/active-user stats
• Falls back from about.json to the subreddit's own sidebar text when the JSON endpoint is blocked, so rollup stats degrade gracefully instead of returning null
• Honors your proxy selection, or defaults to Apify Residential automatically because Reddit returns a 403 to plain datacenter or no-proxy traffic

Features & Capabilities

Core features

• Four target types, one field: mix r/technology, u/spez, https://www.reddit.com/r/news/, and a bare keyword like "artificial intelligence" in the same communities list — each is routed to the correct Reddit listing or search page automatically
• Real velocity, not a proxy metric: velocityScore is computed from Reddit's own data-timestamp attribute (epoch milliseconds), converted to an exact age in hours at scrape time — not derived from Reddit's fuzzy "3 hours ago" text
• Post kind exposed: subredditType on a post row carries Reddit's own data-type value (link or self), and isSelf mirrors it as a boolean
• Subreddit rollup with live community stats: subscribers and activeUsers come from the subreddit's about.json (authoritative), falling back to the sidebar page text when that endpoint is unreachable
• Pagination past Reddit's page size: collect_posts walks Reddit's after cursor across as many listing pages as needed to reach maxPostsPerCommunity, not just the first page
• Promoted content skipped: any .thing element flagged data-promoted="true" is dropped before parsing, so sponsored listings never appear in your post rows or feed into the velocity rollup
• Block-aware fetching: every request is checked against Reddit's own block-page copy ("whoa there, pardner", "you are not allowed to do that") and against response bodies under 1,500 bytes with no post markup, and retried up to 5 times on a fresh proxy IP with a 2-second backoff rather than returned as an empty result

How Reddit Trends Scraper compares to other Reddit scrapers

Checked on the Apify Store on 8 July 2026.

Feature	Reddit Trends Scraper	pintostudio/reddit-trending-subreddit-actor	harshmaur/reddit-scraper
Output format	Typed JSON, stable schema	Typed JSON, stable schema	Typed JSON, stable schema
Post-level scraping	✅ Yes	❌ Subreddit listings only, no posts	✅ Yes
Per-post velocity/engagement score	✅ Computed (upvotes/hr, comments/upvotes)	Not documented	Not documented
Subreddit rollup with live subscriber/active-user stats	✅ Yes, in the same dataset	✅ Yes (its entire output is subreddit metadata)	Not documented as a rollup
Keyword / URL / username input in one field	✅ Yes	❌ Pagination-only (limit/page)	✅ Modes: subreddit, search, user
Comment thread scraping	❌ Not implemented	❌ Not implemented	✅ Yes
AI-agent / MCP connectors	Not implemented	Not documented	✅ Documented (Claude, ChatGPT, Cursor)

If your use case is feeding structured data to an LLM, the output-format row rarely decides it on its own here — all three return typed JSON. The real decision points are entity coverage and the derived metrics: this Actor is the only one of the three that computes a momentum score per post, and the only one that pairs post rows with a live rollup in a single run.

When another tool might suit you better

If you need full comment threads, nested reply trees, or a maintained MCP connector for Claude/ChatGPT/Cursor, harshmaur/reddit-scraper covers that ground and this Actor does not — it returns posts and subreddit rollups only, no comments. If all you need is Reddit's own /subreddits/popular listing with pagination and no per-post data at all, pintostudio/reddit-trending-subreddit-actor's narrower scope may be simpler to wire up.

Reddit Trends Scraper within the Scrapio data stack

Reddit Trends Scraper covers Reddit posts and subreddit-level trend data. For Instagram hashtag momentum, use Instagram Hashtag Analytics Scraper; for tagged UGC engagement, use Instagram UGC Engagement Scraper; for LinkedIn post monitoring by keyword, use LinkedIn Post Keyword Monitor. Together they cover cross-platform trend and engagement tracking from one account.

Why do developers and data teams scrape Reddit?

🏢 Market and competitive intelligence teams

A team tracking a product category adds the relevant subreddits to communities, sets sortBy to top with timeWindow: "week", and reads velocityScore and engagementRate per post to see which discussions are actually gaining traction versus just old high-score threads. The subreddit rollup's avgVelocityScore and topPostTitle give a one-line weekly snapshot per community without opening Reddit at all. Results land in the dataset as JSON or CSV, ready for a spreadsheet or BI tool.

📊 AI training data and RAG indexing

title, flair, and publicDescription (on rollup rows) carry the most descriptive text per record, and velocityScore gives a numeric relevance signal that plain post text can't. For RAG enrichment, index title plus subreddit and flair so an agent can answer "what's trending in r/technology right now" against a live snapshot instead of a stale one. For training data, upvotes, comments, velocityScore, and engagementRate are the most structurally consistent numeric fields across every post record.

📱 Brand and community monitoring

Point communities at a brand name or product keyword to route it through Reddit's search, and track velocityScore per mention over repeated scheduled runs — a mention with rising velocity is worth a response before it reaches the front page. subredditType and subreddit tell you which communities are actually driving the conversation.

🔬 Research and academic use

communities accepts any public subreddit or search term, and every field returned is already visible to an anonymous Reddit visitor — no account or login is used anywhere in the pipeline, which keeps a research dataset limited to genuinely public discourse data.

🎥 Product and SaaS development

The rollup's subscribers, activeUsers, and avgVelocityScore fields are the raw ingredients for a community-health dashboard or a directory product ranking subreddits by current momentum rather than static subscriber count alone.

⬇️ Input Parameters

Parameter	Required	Type	Description	Example Value
communities	✅ Yes	array	Communities to analyze. Add subreddits (e.g. r/technology), full Reddit URLs, user profiles (e.g. u/spez), or search keywords.	["r/technology", "https://www.reddit.com/r/news/", "artificial intelligence"]
sortBy	No	string	How Reddit ranks the pulled posts. hot and rising surface momentum; top/controversial honor timeWindow. Enum: hot (Hot — trending now), rising (Rising — fast movers), new (New — latest), top (Top — highest scored), controversial (Controversial). Default: hot.	"hot"
timeWindow	No	string	Server-side time filter applied when sortBy is top or controversial. Ignored for hot/new/rising. Enum: hour (Past hour), day (Past 24 hours), week (Past week), month (Past month), year (Past year), all (All time). Default: all.	"week"
maxPostsPerCommunity	No	integer	How many posts to pull from each community before computing velocity and the subreddit rollup. Minimum 1. Default: 25.	25
includeSubredditRollup	No	boolean	When on, adds one aggregate record per subreddit (post count, avg/median velocity, avg upvotes & comments, top post) enriched with live subscribers and active-user stats from the community's about.json. Default: true.	true
proxyConfiguration	No	object	Proxy used for requests. Your selection is honored; if left off, Apify Residential is used by default because Reddit blocks datacenter/no-proxy traffic.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

communities is the only required field. There is no credential parameter in this schema — no API key, token, or login field exists, so nothing here is marked as a secret input.

The Actor's code also accepts a set of legacy keys underneath the current schema: startUrls as an alternate for communities, sortOrder as an alternate for sortBy, and maxPosts as an alternate for maxPostsPerCommunity. These are not exposed in the input schema itself — the current field names above are the ones shown in the Apify Console UI and are the ones to use — but if you have an existing input JSON built against the earlier field names, it continues to work unchanged.

Example input

{
  "communities": [
    "r/technology",
    "https://www.reddit.com/r/MachineLearning/",
    "u/spez",
    "large language models"
  ],
  "sortBy": "top",
  "timeWindow": "week",
  "maxPostsPerCommunity": 25,
  "includeSubredditRollup": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Supported target types and input formats

Each entry in communities is classified before it is fetched:

• Subreddit — starts with r/ (e.g. r/technology). Mapped to https://old.reddit.com/r/technology/ (or /top/, /rising/, etc. based on sortBy).
• Full URL — starts with http. Any www.reddit.com or reddit.com host is rewritten to old.reddit.com and the fragment is stripped, so a permalink or subreddit URL copied straight from a browser works unchanged. Example: https://www.reddit.com/r/news/ → https://old.reddit.com/r/news/.
• User profile — starts with u/ or user/, or is a bare word containing no / and no space (e.g. spez). Mapped to https://old.reddit.com/user/spez/submitted/.
• Keyword — anything else, e.g. "large language models". Routed to https://old.reddit.com/search/ with q set to the keyword and sort set to a Reddit-search-valid value (relevance, hot, top, new, or comments — sortBy values outside that set fall back to relevance).

⬆️ Output Format

Every run produces a flat dataset of two record types distinguished by the type field: "post" for individual posts and "subreddit" for the optional per-community rollup (isChild: true on rollup rows). The dataset's default table view surfaces 26 of the fields below; several fields are written to every row but are only visible when you export to JSON or CSV rather than the table view — they are marked below.

Output for a post record

{
  "type": "post",
  "isChild": false,
  "postId": "t3_1abc234",
  "title": "New benchmark shows a 40% jump in local inference speed",
  "postUrl": "https://reddit.com/r/technology/comments/1abc234/new_benchmark_shows/",
  "upvotes": 4821,
  "comments": 612,
  "subreddit": "r/technology",
  "subredditUrl": "https://reddit.com/r/technology",
  "subredditType": "link",
  "author": "some_researcher",
  "authorProfile": "https://reddit.com/user/some_researcher",
  "postTime": "2026-07-24 09:12:40",
  "createdAt": "2026-07-24T09:12:40Z",
  "velocityScore": 201.4,
  "engagementRate": 0.1269,
  "postAgeHours": 23.94,
  "flair": "Hardware",
  "nsfw": false,
  "isSelf": false,
  "stickied": false,
  "domain": "arstechnica.com",
  "scrapedAt": "2026-07-25T09:07:12Z"
}

postId is Reddit's own t3_-prefixed fullname for the post, read straight from the data-fullname attribute — pass it back to Reddit's own URLs or use it to de-duplicate across repeated runs. subredditType on a post row is Reddit's post kind (link or self), read from the data-type attribute on the listing page — it is not the subreddit's own type. isSelf is the boolean form of the same value. The subreddit's actual community type (public, restricted, private) only appears on rollup rows, under the same subredditType key — see below.

Output for a subreddit rollup record

Emitted once per subreddit only when includeSubredditRollup is true (default), and only for subreddits that appear in communities directly or that at least one collected post belongs to.

subscribers, activeUsers, over18, and subredditType are sourced with a three-step fallback: the subreddit's about.json is treated as authoritative when it returns a value; if about.json is blocked or unavailable, the Actor falls back to a page-text regex match against the subreddit's own sidebar (looking for phrasing like "1,234,567 members" or "842 users here now"); if neither source yields a number, the field is written as null rather than a fabricated 0.

{
  "type": "subreddit",
  "isChild": true,
  "postId": null,
  "title": "Technology",
  "postUrl": "https://reddit.com/r/technology",
  "subreddit": "r/technology",
  "subredditUrl": "https://reddit.com/r/technology",
  "subredditType": "public",
  "author": null,
  "authorProfile": "",
  "postTime": "",
  "createdAt": "2008-01-25T05:07:59Z",
  "postCount": 25,
  "avgVelocityScore": 84.217,
  "medianVelocityScore": 41.6,
  "avgUpvotes": 2140.32,
  "totalUpvotes": 53508,
  "avgComments": 187.4,
  "totalComments": 4685,
  "avgEngagementRate": 0.0874,
  "topPostTitle": "New benchmark shows a 40% jump in local inference speed",
  "topPostUrl": "https://reddit.com/r/technology/comments/1abc234/new_benchmark_shows/",
  "topPostVelocityScore": 201.4,
  "subscribers": 18342211,
  "activeUsers": 9184,
  "publicDescription": "The largest tech-focused community on Reddit.",
  "over18": false,
  "scrapedAt": "2026-07-25T09:07:40Z"
}

avgEngagementRate, totalUpvotes, totalComments, topPostUrl, topPostVelocityScore, and publicDescription are written on every rollup row but sit outside the 26-field default table view — pull them from the JSON or CSV export. Likewise postId, nsfw, isSelf, stickied, and domain are written on every post row but sit outside the default view. Nothing is omitted from the dataset itself; only the table view is a subset.

Velocity and engagement formula, exactly as implemented:

• postAgeHours = (now_utc − createdAt) in hours, computed at scrape time from Reddit's own data-timestamp (epoch milliseconds), rounded to 3 decimals.
• velocityScore = upvotes ÷ postAgeHours, rounded to 3 decimals. Only computed when postAgeHours > 0; otherwise null.
• engagementRate = comments ÷ upvotes, rounded to 4 decimals. Only computed when upvotes is a nonzero number; otherwise null.
• Rollup avgVelocityScore / medianVelocityScore are the mean/median of every non-null velocityScore in the subreddit's collected posts, rounded to 3 decimals; avgUpvotes/avgComments are means rounded to 2 decimals; totalUpvotes/totalComments are sums (0 if no posts had a value); avgEngagementRate is the mean of non-null engagementRate values, rounded to 4 decimals.
• The rollup's top post is the post with the highest velocityScore in that subreddit's collected set (ties broken by upvotes), not necessarily Reddit's own "top" sort.

What you're charged for

This Actor uses Apify's pay-per-event pricing with a single charged event, post_result, billed once per post row (type: "post"). Subreddit rollup rows (type: "subreddit", isChild: true) are written to the dataset with no charged_event_name attached, so turning on includeSubredditRollup adds the aggregate rows to your dataset at no additional per-row cost — you only pay for the posts collected, not the summary built on top of them. To separate the two after a run, filter the dataset on type == "post" for billed rows versus type == "subreddit" for the free rollups.

Schema stability and export options

Field names are fixed by this Actor's own code, not by Reddit's front end — a Reddit redesign that changes on-page layout does not change your field names, since parsing reads the .thing element's data-* attributes and the about.json payload rather than visual markup. Export the dataset as JSON, CSV, Excel, or XML from the Apify Console, or read it through the Apify API or apify_client.

Reddit Trends Scraper Strategy Guide

🎯 Strategy 1: Real-time momentum enrichment

Feed a list of subreddits or keywords relevant to your product or brand, run with sortBy: "hot", and append velocityScore and engagementRate to each incoming record in your CRM or lead-tracking system as an urgency signal — a mention with velocityScore above your threshold gets routed to a human faster than one sitting at zero. The Actor returns the enrichment fields already computed; no post-processing step is required before the write-back.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify Schedule to run the same communities list daily or hourly with includeSubredditRollup: true. Diff each run's avgVelocityScore and topPostTitle per subreddit against the previous run's dataset, keyed on subreddit — a jump in avgVelocityScore or a new topPostTitle is the delta worth alerting on. Apify Schedules and the Actor's webhook on run completion cover the trigger; the diff logic runs downstream against the two datasets.

🎯 Strategy 3: Bulk trend dataset build

For a research or historical dataset, run the Actor against a large communities list with maxPostsPerCommunity set to your target depth per community, then export the combined dataset to CSV for aggregation in pandas, R, or a data warehouse. Each run's scrapedAt timestamp lets you stack multiple runs into a longitudinal dataset keyed on postId.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Lead/mention scoring on inbound records	Single on-demand run per trigger	JSON row appended per record
Scheduled monitoring	Ongoing community/brand tracking	Apify Schedule, recurring run	Dataset diffed run-over-run
Bulk dataset build	Research or historical trend datasets	One large run across many subreddits	CSV/JSON export for offline analysis

🔗 Related Reddit Scrapers & Tools

There is no second Reddit-specific Actor in the Scrapio catalogue at this time — Reddit Trends Scraper is the only one. For adjacent cross-platform trend and engagement monitoring from the same account:

Scraper Name	What it extracts
Instagram Hashtag Analytics Scraper	Hashtag and keyword momentum on Instagram
Instagram UGC Engagement Scraper	Engagement on tagged-profile Instagram content
LinkedIn Post Keyword Monitor	Keyword-matched post tracking on LinkedIn

How to integrate Reddit Trends Scraper with your stack

Reddit Trends Scraper works with any language or tool that can call the Apify API. Below are the two most common paths.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/reddit-trends-scraper-trending-subreddit-velocity-report").call(run_input={
    "communities": ["r/technology", "r/MachineLearning"],
    "sortBy": "top",
    "timeWindow": "week",
    "maxPostsPerCommunity": 25,
    "includeSubredditRollup": True,
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
posts = [r for r in rows if r["type"] == "post"]
rollups = [r for r in rows if r["type"] == "subreddit"]

posts.sort(key=lambda p: p.get("velocityScore") or 0, reverse=True)
for p in posts[:10]:
    print(p["velocityScore"], p["subreddit"], p["title"])

for r in rollups:
    print(r["subreddit"], r["avgVelocityScore"], r["subscribers"])

Node.js

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('<YOUR_USERNAME>/reddit-trends-scraper-trending-subreddit-velocity-report').call({
  communities: ['r/technology', 'r/MachineLearning'],
  sortBy: 'top',
  timeWindow: 'week',
  maxPostsPerCommunity: 25,
  includeSubredditRollup: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const posts = items.filter((i) => i.type === 'post');
posts.sort((a, b) => (b.velocityScore ?? 0) - (a.velocityScore ?? 0));
console.log(posts.slice(0, 10).map((p) => [p.velocityScore, p.subreddit, p.title]));

No-code tools (n8n, Make, Zapier)

In n8n, use the Apify node — or an HTTP Request node pointed at the Apify run endpoint with your token — and pass the same JSON input shown above. In Make, use the Apify module and map the dataset output straight into a Google Sheets or Airtable step. Both handle scheduling natively, so a weekly subreddit velocity sweep needs no code.

Async and scheduled pipelines

For large communities lists, start the run through the Apify API and poll the run status or the dataset's item count rather than waiting synchronously — the run continues on Apify's infrastructure independent of your client connection. For recurring monitoring, create an Apify Schedule against this Actor with a fixed communities input and a cron expression; each scheduled run writes to its own dataset, which you then read via the API or Console on your own cadence.

Who Needs Reddit Trends Scraper? (Use Cases & Industries)

🏢 Market and competitive intelligence teams

A team monitoring a product category runs sortBy: "top" with timeWindow: "week" against the relevant subreddits and reads velocityScore per post to separate posts still gaining traction from ones that peaked and stalled — a faster signal than static upvote count alone.

📊 AI/ML engineers building RAG or agent tools

title, flair, subreddit, and velocityScore index cleanly into a vector store or agent tool so a model can answer "what's trending in r/technology this week" against a live dataset rather than a training-cutoff snapshot.

📱 Brand and social monitoring teams

Route a brand or product keyword through communities and track velocityScore per mention across scheduled runs — a mention accelerating past your threshold is worth a same-day response.

🔬 Researchers

Academic and market researchers studying public discourse patterns can point communities at any public subreddit or search term; every field returned is already visible to an anonymous Reddit visitor, keeping the dataset limited to genuinely public data.

Is it legal to scrape Reddit?

Scraping publicly accessible web data is broadly permitted in the United States — in hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir. 2019), the court held that scraping data not behind a login wall does not violate the Computer Fraud and Abuse Act. Reddit Trends Scraper only reads pages and community metadata that any anonymous, logged-out visitor can already see.

That does not mean every use is risk-free. Reddit's own User Agreement restricts automated access in ways that create civil, not criminal, exposure — a Terms of Service violation is a contract matter between you and Reddit, not a scraping-specific offense. Separately, post author usernames are pseudonymous identifiers tied to public content; depending on your jurisdiction and how you store or combine that data, data protection rules such as GDPR or CCPA may apply to the author/authorProfile fields specifically, even though the post and subreddit content itself is a public forum record.

Reddit Trends Scraper returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data such as usernames.

❓ Frequently asked questions

Does Reddit Trends Scraper work without a Reddit account?

Yes. No Reddit account, login, cookie, or API key is used anywhere in the code — every request is an anonymous GET to old.reddit.com or a subreddit's public about.json endpoint. The only credential you need is your Apify token.

How does Reddit Trends Scraper handle Reddit's anti-scraping measures?

Every fetch is retried up to 5 times on a fresh proxy IP when Reddit returns a 403/429/500/502/503 status, waiting 2 seconds between attempts, or when the response body matches Reddit's own block-page copy or is under 1,500 bytes with no post markup. The about.json community-stats fetch has its own retry loop — up to 3 attempts per host, tried against www.reddit.com first and old.reddit.com second. Requests go through Apify Proxy — your selection is honored, and Residential is used by default because Reddit returns a 403 to plain datacenter or no-proxy traffic.

Does Reddit Trends Scraper include promoted or sponsored posts?

No. Any listing element Reddit marks data-promoted="true" is filtered out before parsing, so sponsored placements never appear in your post rows and are excluded from the subreddit rollup's averages and top-post calculation.

Can I run Reddit Trends Scraper at scale without getting blocked?

The Actor retries through fresh proxy sessions on a block and continues with the remaining communities if one target cannot be recovered after its retry budget — no uptime or success-rate figure is published for this behavior. Requests within a single run go through a connection pool capped at 10 concurrent connections.

How fresh is the data Reddit Trends Scraper returns?

Live. Every run fetches old.reddit.com and about.json directly at run time — nothing is cached or served from a prior run. scrapedAt on every row is the UTC timestamp of that specific run.

Which fields work best for AI training and RAG indexing?

For RAG: title, flair, and the rollup's publicDescription carry the most descriptive text and chunk cleanly. For training data: upvotes, comments, velocityScore, and engagementRate are the most structurally consistent numeric fields across every post record. All fields are returned as typed primitives — no normalization pass is required before indexing.

Does Reddit Trends Scraper work with Claude, ChatGPT, and other AI agent tools?

It is callable as a standard Apify Actor run through the Apify API, so any agent framework that can make an HTTP request — LangChain, CrewAI, a custom tool definition — can trigger a run and read back typed JSON with no parsing step. No dedicated MCP server is documented for this Actor.

What's the difference between postTime and createdAt?

Both are derived from the same Reddit data-timestamp value, but formatted differently. postTime is a legacy-format string ("2026-07-24 09:12:40", space-separated, no timezone marker) kept for compatibility with the earlier field convention. createdAt is the same instant as a proper ISO-8601 UTC string ("2026-07-24T09:12:40Z"). Use createdAt for anything you plan to parse programmatically.

What happens if a subreddit or search returns zero posts?

No row is written for that target. The run logs that zero posts were collected and moves to the next entry in communities; if includeSubredditRollup is on, no rollup row is produced for a subreddit with no collected posts either.

How does Reddit Trends Scraper compare to other Reddit scrapers?

Checked on the Apify Store on 8 July 2026: pintostudio/reddit-trending-subreddit-actor only paginates Reddit's own trending-subreddit listing (limit/page) — no post-level data and no velocity metric. harshmaur/reddit-scraper is the broadest of the three, with full comment-thread scraping and documented MCP connectors for Claude, ChatGPT, and Cursor, but does not document a computed velocity or engagement score. Reddit Trends Scraper's difference is the pairing of per-post momentum metrics with a live subreddit rollup in the same dataset, from a single input list mixing subreddits, users, URLs, and keywords.

Disclaimer

Reddit Trends Scraper extracts only publicly available data from Reddit. This tool is intended for lawful use cases only. Users are responsible for complying with Reddit's terms of service and applicable data protection laws in their jurisdiction.

💬 Your feedback

Found a bug, or need a field that Reddit's page already carries but this Actor doesn't return? Open an issue on the Actor's Issues tab with a sample subreddit or post URL — that is the fastest path to a fix.