Reddit Trends Scraper By Sort, Time & Score Filter

Reddit Trends Scraper — Sorted Posts with Upvotes and Comments

Reddit Trends Scraper returns trending Reddit posts as structured JSON: the post title, its upvote score and comment count, the subreddit and subreddit type, the flair, the NSFW flag, the author and the post's UTC creation time. Point it at subreddits, usernames, search terms or Reddit URLs, choose a sort order and time window, then filter by minimum upvotes, minimum comments, NSFW and keywords. No Reddit account, login or API key is involved. One field is required — paste a target and press Start.

⚠️ Read the section on what "trends" means here before your first run. Reddit publishes no trend board, the score and keyword filters run after fetching rather than on Reddit's side, and a bare one-word target is treated as a username, not a subreddit. All three are explained below.

What is Reddit Trends Scraper?

Reddit Trends Scraper is an Apify Actor that reads the public, logged-out listing HTML of old.reddit.com and shapes each post row into one flat, typed record with 14 keys. It reads the structured data-* attributes that old.reddit renders on every post element, so the values come from markup Reddit itself emits rather than from scraped display text.

No Reddit account, login, cookie, OAuth token, client ID or API key is required, and no captcha-solver key either. The only credential in play is your Apify token. Requests go out logged-out, through whatever proxy you select.

It is built for social listening and brand-monitoring teams tracking what is climbing in a subreddit, content and community researchers who need the top of a feed for a specific window, and developers feeding Reddit post signals into dashboards, alerting jobs or agent tools.

What Reddit post data is publicly available to scrape?

A logged-out visitor to a subreddit, user page or search results page sees the full post listing: titles, permalinks, scores, comment counts, subreddit, flair, NSFW state, author handle and post age. What that visitor does not see is anything inside a private or approved-users-only community, and Reddit does not publish an exact, stable vote count to anyone.

Data category	Public on logged-out Reddit	Gated, or not returned by this Actor
Post title, permalink and post ID	✅ Public	—
Upvote score and comment count	✅ Public — but fuzzed by Reddit, and hideable by the poster	—
Subreddit name, URL and access type	✅ Public	—
Post flair and NSFW (over_18) flag	✅ Public	—
Author username and profile URL	✅ Public	—
Post creation time	✅ Public	—
Post body text, images, thumbnails, link domain	✅ Public on Reddit	❌ Not returned — this Actor reads the listing row, not the post page
Comments and reply threads	✅ Public on Reddit	❌ Not returned — no comment fetching in this Actor
Exact unfuzzed vote counts, upvote ratio	❌	Reddit does not publish them
Posts in private or approved-users-only subreddits	❌	Reddit account plus approval
Author email, IP, subscriptions, saved posts	❌	Never public

Reddit Trends Scraper only returns publicly visible data — what any logged-out visitor sees on a listing page. Nothing behind a login wall.

⚠️ What "trends" means here, and three behaviours worth knowing

Reddit publishes no trends endpoint, and this Actor does not pretend otherwise. There is no ranked trend board on Reddit the way there is on X, and no trend name, trend rank or trend volume field anywhere in this output. What "trends" means for this Actor is precise and small: the top of a Reddit listing, sorted the way you asked. You pick hot, new, top, rising or controversial; Reddit orders its own feed; the Actor reads the first N posts that survive your filters. hot and rising are Reddit's own popularity rankings, so r/popular on hot is about as close to "what is trending on Reddit right now" as the public site gets — but the ranking is Reddit's, not something this Actor computes.

Two of the settings run on Reddit's side; the filters run after fetching. This matters for how many pages get fetched and for what you pay:

Setting	Where it is applied
sortBy	Server-side. Passed to Reddit — as a path segment for subreddits (/r/<sub>/top/), as ?sort= for user pages and search
timeWindow	Server-side. Reddit's own t= parameter — but only sent for the top and controversial sorts, and for keyword searches
minUpvotes	After fetching. Reddit has no minimum-score parameter; the Actor compares the score it parsed
minComments	After fetching. Same — no server-side equivalent exists
includeNSFW	After fetching. Compared against the post's own NSFW attribute
keywords / excludeKeywords	After fetching. Case-insensitive substring match over the title and flair

A post dropped by any of the four post-fetch filters is never written to the dataset and therefore never charged — the charge is per saved row. It was still fetched, so it still cost a page request; the Actor simply keeps paginating until it has maxPosts survivors or Reddit runs out of listing.

The upvotes value is a fuzzed, point-in-time number. Reddit deliberately fuzzes the vote counts it serves, so upvotes is Reddit's approximation at the moment of fetch rather than a stable property of the post — two runs minutes apart can legitimately disagree, and minUpvotes is therefore a threshold against a snapshot, not an exact cut.

Three smaller behaviours that will bite you if you do not know them:

• A bare one-word target is read as a username. r/technology is a subreddit, u/spez or user/spez is a user, and a multi-word string like machine learning is a keyword search — but a single word with no slash and no space, such as technology, is treated as u/technology and fetches that user's submitted posts. Always prefix subreddits with r/, or paste the full URL. The sibling Actor listed below uses the opposite convention for bare words, so do not carry the habit across.
• The keyword filters read the title and flair only. Not the post body — the Actor never fetches post pages, so there is no body text to search. Matching is plain case-insensitive substring, so a short term like ai also matches "said" and "chain"; use distinctive words or phrases.
• Invalid values fall back silently. A sortBy outside the five options becomes hot, and a timeWindow outside the six becomes all, with no error raised. The Console dropdowns make this impossible; it can only happen over the API.

What data can I extract with Reddit Trends Scraper?

Every row carries the post itself, its two engagement counts, its subreddit context, its author, and two representations of the same creation timestamp. Fourteen keys on every row, always present — the default dataset view shows all fourteen, so what you see in the table is what is in the JSON.

Field Name	Description
title	Post title as rendered on the listing. A post whose title parses empty is skipped entirely rather than emitted blank
postUrl	Absolute link to the post on www.reddit.com, built from Reddit's own permalink. Empty string if the listing row carries no permalink
upvotes	Integer score Reddit reported for the post at fetch time. null when Reddit hides or omits the score — those rows are dropped when minUpvotes is above 0
comments	Integer comment count Reddit reported for the post. null when the count is missing or unparsable
createdAt	Post creation time in ISO 8601 UTC, e.g. 2026-07-24T14:31:07Z. null when Reddit omits the timestamp
postTime	The same creation time as YYYY-MM-DD HH:MM:SS, also UTC but without a zone marker. Empty string when the timestamp is missing
subreddit	Prefixed subreddit name exactly as Reddit renders it, e.g. r/technology
subredditUrl	Absolute subreddit link built from the bare slug, e.g. https://www.reddit.com/r/technology. Empty string when the slug is missing
subredditType	Reddit's own access type for the community — public, restricted, and so on. null when the attribute is absent
flair	Link flair text, e.g. Artificial Intelligence. null when the post has no flair
nsfw	Boolean, from the post's own NSFW attribute. Always true or false, never null
author	Author username without the u/ prefix. Comes back as [deleted] when the account is gone
authorProfile	Absolute profile link, e.g. https://www.reddit.com/user/spez. Empty string when the author is [deleted] or missing — that is the flag for a removed account
postId	Reddit's base-36 post ID with the t3_ prefix stripped, e.g. 1abc2de. The stable key to deduplicate on

Keys are never omitted. Every row has all fourteen; a missing value arrives as null (upvotes, comments, createdAt, subredditType, flair) or as an empty string (postTime, postUrl, subredditUrl, authorProfile), depending on the field.

Post, subreddit and flair fields

title, postUrl and postId identify the post; subreddit, subredditUrl and subredditType place it. subreddit arrives prefixed (r/technology) while subredditUrl is built from the bare slug, so strip the r/ if you are joining the two. subredditType earns its place when you scrape r/popular or a search, because a single run then spans many communities with different access models. flair is the most useful free-text field after the title — many large subreddits use it as a topic taxonomy, which is exactly what the keywords filter matches against.

Engagement, timing and safety fields

upvotes and comments are the two numbers you threshold and rank on, and both are typed integers or null — never strings, never "48.2k". nsfw is a real boolean read from the post's own attribute rather than inferred from the subreddit. The two time fields come from the same underlying epoch value: use createdAt for anything you sort, join or store, since it is ISO 8601 with an explicit Z, and treat postTime as the human-readable rendering of the same instant. Neither is the scrape time — there is no scrape-time field on the row, so stamp your own if you need one.

🤖 Add-on: Need additional Reddit data?

This Actor reads listing rows, which means no post bodies and no comments. When you need those, Reddit Posts Scraper by Keyword & Score Filter returns the post body, images and a comments array for each matching post, and Reddit User Profile Posts and Comments Scraper with Account Age comes at Reddit from the account side, adding karma, cake day and account age to every row. For the same "what is moving right now" question on other platforms, Twitter Trends Scraper and TikTok Trending Hashtags Scraper by Multiple Countries cover the two places a topic usually shows up next.

How does Reddit Trends Scraper differ from the official Reddit Data API?

Reddit does publish an official Data API, and if your use case fits it, use it — it is the supported route, it returns fields no listing page renders, and it comes with terms you can point at. It also requires you to register an application, hold credentials, and stay inside terms that treat commercial and high-volume use differently from personal use. This Actor exists for the case where you want listing data without standing up that integration.

Feature	Official Reddit Data API	Reddit Trends Scraper
Registered app and credentials	Required	❌ None — logged-out public pages only
Data scope	Reddit's documented API objects, including fields no listing renders	The 14 listing fields documented above
Post bodies and comments	Available through the API	❌ Not returned
Sort and time window	Supported by the API	✅ Five sorts, six time windows, passed straight through
Score, comment, NSFW and keyword filtering	You implement it client-side	✅ Built in, and filtered-out posts are never charged
Output shape	Reddit's API schema, which you map yourself	One flat, typed 14-key row, stable across runs
Rate and commercial terms	Set and enforced by Reddit	Set by your Apify run and your proxy choice

Rate limits, quota tiers and the commercial-use conditions attached to the official API are Reddit's to define and they change — verify them against Reddit's current published API terms rather than against any figure quoted in a Store listing, this one included. Use the official API when you need post bodies, comments or a contractual basis for commercial use; use this Actor for fast, filtered listing snapshots without an application review.

How to use Reddit Trends Scraper

Reddit Trends Scraper runs on Apify. Start it from the Apify Console or call it through the Apify API.

1. Open Reddit Trends Scraper on Apify and click Try for free
2. Fill 🎯 Reddit Targets (startUrls) — this is the one required field. Add r/technology, u/spez, a multi-word search term, or a full Reddit URL. Prefix subreddits with r/
3. Pick 🔀 Sort By and 🕒 Time Window. The window applies to top and controversial and to keyword searches; hot, new and rising ignore it
4. Set the filters you want — 👍 Minimum Upvotes, 💬 Minimum Comments, 🔞 Include NSFW, and the include / exclude keyword lists
5. Set 📦 Max Posts, remembering it counts posts after filtering, per target
6. Click Start, then export as JSON, CSV or Excel, or read the dataset through the Apify API

startUrls is the only required parameter, and a run without it does nothing rather than failing loudly. The Actor logs No targets provided in startUrls., exits cleanly and writes an empty dataset — no error status, no rows, no charges. If a run finishes suspiciously fast with zero results, check that field first. Everything else has a default: hot, all time, no thresholds, NSFW included, ten posts per target.

How to scale to bulk Reddit post extraction

startUrls is a list, so bulk is native: put twenty subreddits in it and the Actor works through them one after another, applying the same sort, window and filters to each and collecting up to maxPosts survivors from every one. Targets can be mixed freely — subreddits, users, search terms and full URLs in the same run. Each target paginates independently, and a target that fails or gets blocked is logged and skipped so the remaining targets still run.

Two things bulk does not do. sortBy and timeWindow are single values per run, so covering top / week and rising for the same subreddit means two runs. And there is no deduplication anywhere — if the same post matches two targets, or Reddit reshuffles a live listing between pages, you get two rows and two charges. Deduplicate on postId on your side.

What can you do with Reddit post data?

• 📣 A brand monitoring analyst watching a product category runs r/technology and r/gadgets on top / day with keywords set to the brand names, then reads upvotes and comments to see which mention actually got traction rather than which merely exists.
• 📰 A community manager preparing a weekly digest runs top with timeWindow: "week" and minUpvotes set high enough to cut the long tail, then publishes title and postUrl straight from the dataset.
• 📈 A trend researcher compares rising against hot for the same subreddit in two runs and diffs on postId to separate posts that are climbing from posts that already peaked.
• 🧪 A product researcher hunting complaint threads sets keywords to terms like refund or outage, sets minComments high enough to skip ignored posts, and works the resulting postUrl list as a qualitative reading queue.
• 🤖 An AI engineer building a social-listening agent indexes title, flair and subreddit into a vector store keyed on postId, so the agent answers "what is r/MachineLearning arguing about this week" from observed rows instead of stale training data.
• 🛡️ A moderation or safety researcher runs controversial with includeNSFW off and uses subredditType and nsfw to keep the sample inside public, non-adult communities.

Every one of these is callable from an agent framework over the Apify API, since the Actor is a standard HTTP-triggered run.

How does Reddit Trends Scraper handle rate limits and blocking?

Reddit blocks by TLS fingerprint before it ever looks at your headers, which is why this Actor does not use a plain HTTP client. Requests are issued through curl_cffi with a real browser TLS impersonation, and the Actor rotates through four of them — safari17_0, chrome131, safari15_5, chrome124 — because Reddit's bot wall challenges some fingerprints and not others. Each request carries browser-style Accept, Accept-Language and Referer headers and a 45-second timeout. There is no headless browser and no JavaScript execution.

A response counts as blocked when the status is not 200, when the body is shorter than 1,500 characters, or when the opening of the page contains Reddit's block text — so a soft block dressed as a 200 is caught rather than parsed into empty rows. On a block the Actor waits 2 seconds, draws a fresh proxy URL from your proxy configuration and retries with the next fingerprint: up to four attempts while no row has landed for that target yet, two attempts once rows are flowing. There is no captcha solving anywhere in this Actor, because what it meets is a fingerprint block rather than a challenge page.

Between listing pages the Actor pauses 2 seconds. If every attempt on a page is blocked, that target stops with a warning and the run continues with the next one — no rows are written for it, and nothing is charged.

⬇️ Input

Ten parameters, one of them required, read straight from the input schema.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Reddit targets, stringList editor. Accepts subreddits (r/popular), usernames (u/spez or user/spez), multi-word search terms, and full Reddit URLs. A bare single word with no slash or space is read as a username. Prefilled with https://www.reddit.com/r/popular/. A run with an empty list writes nothing.	["r/technology", "u/spez", "machine learning"]
maxPosts	No	integer	Maximum posts returned per target, counted after filtering. The Actor paginates until it has this many survivors or the listing is exhausted. Minimum 1, default 10. No upper bound in the schema.	25
sortBy	No	string	Server-side listing sort. Closed enum of five: hot, new, top, rising, controversial. Default hot. A value outside the enum silently falls back to hot.	"top"
timeWindow	No	string	Reddit's t= range. Closed enum of six: hour, day, week, month, year, all. Default all. Sent only for the top and controversial sorts and for keyword searches; ignored by hot, new and rising. An out-of-enum value falls back to all.	"week"
minUpvotes	No	integer	Keep only posts scoring at least this. Applied after fetching. Minimum 0, default 0 (no threshold). Above 0, posts whose score Reddit hides are dropped.	500
minComments	No	integer	Keep only posts with at least this many comments. Applied after fetching. Minimum 0, default 0 (no threshold).	50
includeNSFW	No	boolean	When true, NSFW posts are kept; when false, they are dropped after fetching. Default true.	true
keywords	No	array	Keep only posts whose title or flair contains at least one of these, case-insensitive substring match. stringList editor, default empty (keep all).	["ai", "gpu"]
excludeKeywords	No	array	Drop posts whose title or flair contains any of these, case-insensitive substring match. stringList editor, default empty.	["giveaway", "megathread"]
proxyConfiguration	No	object	Proxy for the Reddit requests, proxy editor. Your selection is honoured as-is — no proxy, Apify datacenter, Apify residential, or your own URLs. Prefilled {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

What each enum value actually returns. hot is Reddit's default popularity ranking for a community. new is strict reverse-chronological. top is highest-scoring inside the chosen window. rising is Reddit's fast-gaining-traction feed, which is typically much shorter than the others. controversial is Reddit's mixed-vote ranking for the chosen window. On the time side, hour, day, week, month and year restrict top and controversial to posts from the past hour, 24 hours, 7 days, 30 days and 12 months respectively, and all removes the restriction. On hot, new and rising the window is simply not sent, so changing it changes nothing.

How each target maps to a Reddit URL. A subreddit becomes /r/<sub>/<sort>/ — with hot served by the bare listing, since that is old.reddit's default. A username becomes /user/<name>/submitted/ with ?sort=, which means submitted posts only, never that user's comments. A search term becomes /search/?q=… with restrict_sr=off, so keyword searches run across all of Reddit and cannot be scoped to one subreddit here; on search, rising and controversial are not valid Reddit search sorts and both fall back to relevance, while the time window is always applied. Any other URL path is fetched as-is with the sort and time parameters appended, and whatever old.reddit renders there goes through the same post parser.

Two things the schema does not show. sortOrder is accepted as a legacy alias for sortBy — {"sortOrder": "top"} works, and sortBy wins when both are set. And the source mentions a legacy maxComments key: it is not read by this Actor, so passing it does nothing. This Actor never fetches comments.

Example input

The week's top technology posts above 500 upvotes, AI-related, excluding giveaway threads, plus one user's submissions:

{
  "startUrls": [
    "r/technology",
    "r/MachineLearning",
    "u/spez"
  ],
  "maxPosts": 25,
  "sortBy": "top",
  "timeWindow": "week",
  "minUpvotes": 500,
  "minComments": 50,
  "includeNSFW": false,
  "keywords": ["ai", "gpu", "model"],
  "excludeKeywords": ["giveaway", "megathread"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Example input — trending right now

r/popular on hot is the closest public equivalent to a Reddit-wide trending feed. The time window is ignored by hot, so it stays at its default:

{
  "startUrls": ["https://www.reddit.com/r/popular/"],
  "maxPosts": 50,
  "sortBy": "hot",
  "includeNSFW": false
}

⬆️ Output

One dataset row per surviving post, typed and normalized, with the same fourteen keys on every run. Rows are pushed as each page is parsed, so the dataset fills while the run is still going and a target that gets blocked later never loses what already landed. Export as JSON, CSV or Excel, or read the dataset through the Apify API.

There are no error rows, diagnostic rows or accounting rows in this dataset — at all. The only thing this Actor ever writes is a post row, and every written row is charged exactly one post_result event. Failures are logged, not pushed: a blocked page, an exhausted listing, an unreachable target and an empty startUrls all produce log lines and nothing in the dataset. So there is no errorReason, status, success or isError marker to filter on, because there is nothing to filter out — every row you receive is a real post. Posts rejected by your filters, promoted advertisement rows, and non-post entries are all discarded before the push and never charged.

Deduplication does not happen anywhere. The same post can appear twice if it matches two targets, or if Reddit reorders a live listing between pages. postId is the stable key to deduplicate on.

Example output

A row from the r/technology top / week slice:

{
  "title": "Nvidia says its next-gen data centre GPU is sold out through 2027",
  "postUrl": "https://www.reddit.com/r/technology/comments/1abc2de/nvidia_says_its_nextgen_data_centre_gpu_is_sold/",
  "upvotes": 48213,
  "comments": 3127,
  "subreddit": "r/technology",
  "subredditUrl": "https://www.reddit.com/r/technology",
  "subredditType": "public",
  "author": "hardware_watcher",
  "authorProfile": "https://www.reddit.com/user/hardware_watcher",
  "postTime": "2026-07-21 14:31:07",
  "postId": "1abc2de",
  "createdAt": "2026-07-21T14:31:07Z",
  "nsfw": false,
  "flair": "Artificial Intelligence"
}

A row from the same run where the author deleted their account and the post carries no flair — note that authorProfile is an empty string while flair is null:

{
  "title": "After 6 months running an open model on my own GPUs, here is what it actually cost",
  "postUrl": "https://www.reddit.com/r/MachineLearning/comments/1xyz9fg/after_6_months_running_an_open_model_on_my_own/",
  "upvotes": 9042,
  "comments": 611,
  "subreddit": "r/MachineLearning",
  "subredditUrl": "https://www.reddit.com/r/MachineLearning",
  "subredditType": "public",
  "author": "[deleted]",
  "authorProfile": "",
  "postTime": "2026-07-23 08:02:44",
  "postId": "1xyz9fg",
  "createdAt": "2026-07-23T08:02:44Z",
  "nsfw": false,
  "flair": null
}

How does it work?

For each target you list, the Actor works out what it is — subreddit, user, search term or raw URL — and builds the matching old.reddit listing URL with your sort and time window attached. It then issues plain HTTP GETs through curl_cffi with a browser TLS impersonation, asking Reddit for up to 100 posts per page and following Reddit's own next-page token until it has enough surviving posts or the listing ends. There is no headless browser, no login and no cookie jar.

Each page is parsed by reading the structured data-* attributes Reddit renders on every post element — score, comment count, subreddit type, NSFW flag, author, permalink and epoch timestamp — rather than by scraping display text, which is why upvotes comes back as 48213 and not "48.2k". Promoted rows and non-post entries are dropped before your filters even run, and only survivors are written.

Only publicly visible, logged-out data is collected. How deep a listing goes is Reddit's decision, not the Actor's: pagination continues only while Reddit keeps returning a next-page token, and Reddit truncates its listing feeds well before an exhaustive archive. The Actor imposes no page or depth cap of its own — it caps only the per-page size it asks for, at 100. Your field names and types stay the same regardless of what Reddit does to its layout.

Integrations

Reddit Trends Scraper is an Apify Actor, so it works with anything that can call the Apify API or consume a dataset.

Calling Reddit Trends Scraper from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/reddit-trends-scraper-by-sort-time-score-filter").call(run_input={
    "startUrls": ["r/technology", "r/MachineLearning"],
    "sortBy": "top",
    "timeWindow": "week",
    "minUpvotes": 500,
    "maxPosts": 25,
})

seen = set()
for rec in client.dataset(run["defaultDatasetId"]).iterate_items():
    if rec["postId"] in seen:
        continue
    seen.add(rec["postId"])
    print(rec["upvotes"], rec["comments"], rec["subreddit"], rec["title"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request. The seen set is doing real work here: nothing deduplicates on the Actor's side.

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; a Filter node on upvotes or a Remove Duplicates node on postId cleans the feed before it reaches your sheet or Slack step. In Make, the Apify module supports run-and-wait, so a daily top / day pull can feed a Google Sheets, Airtable or Slack step directly. Both platforms handle scheduling, which is how you turn a one-off hot snapshot into a rolling record of what a subreddit surfaced each hour.

Is it legal to scrape Reddit posts?

Scraping publicly accessible posts is broadly treated as permissible where no authentication is bypassed, and this Actor reads only logged-out listing pages — no account, no cookie, no session.

This output contains personal data. Two fields carry it directly — author and authorProfile — and title and flair are free text that can name people. A Reddit username is pseudonymous, but under GDPR and UK GDPR it is still personal data, because it identifies the same individual consistently across every post they make. That matters more than it first appears: assembling one pseudonymous author's posting history across subreddits, times of day and topics reveals considerably more about that person than any single post does.

Practical consequences under GDPR, UK GDPR and the CCPA: establish a lawful basis before you store rows, since legitimate interests is the usual route and it needs a documented balancing test; apply data minimisation — if your analysis only needs title, upvotes, comments and subreddit, drop author and authorProfile at ingest and most of the personal-data question goes away; set a retention period rather than keeping rows indefinitely; and have a process for access and erasure requests, which postId and author make straightforward to service. Reddit's own terms of service and its rights in the aggregated content apply on top of all of this.

Consult legal counsel if your use case involves bulk storage of personal data, profiling individual Reddit users, or republishing this data as a dataset.

❓ Frequently asked questions

What Reddit post fields does Reddit Trends Scraper return?

The five most used are title, upvotes, comments, subreddit and postUrl. Every row carries fourteen keys in total, adding flair, nsfw, subredditType, author, authorProfile, postId, createdAt, postTime and subredditUrl. See the data fields table above for all of them.

Does Reddit Trends Scraper require a Reddit account, login or API key?

No. No Reddit account, no login, no cookie, no OAuth token, no registered application and no client ID. It reads logged-out old.reddit listing pages, which is also why it cannot see private or approved-users-only communities. The only credential involved is your Apify token.

Is this Reddit's official trending ranking?

No — Reddit does not publish a trend board or a trends endpoint, and there is no trend name, trend rank or trend volume field in this output. "Trends" here means the top of a Reddit listing sorted the way you choose. hot and rising are Reddit's own popularity rankings of posts, so r/popular on hot is the closest public equivalent to a site-wide trending feed, but the ranking is Reddit's and this Actor reports it rather than computing one.

How many posts can I extract in one run?

maxPosts sets the ceiling per target, counted after filtering, and the schema puts no upper bound on it — ten targets at maxPosts: 50 is a 500-row run. The real ceiling is Reddit's: pagination continues only while Reddit keeps returning a next-page token, and Reddit truncates its listing feeds well before an exhaustive archive, so a very high maxPosts on a small or heavily filtered subreddit simply stops when the listing runs out. Tight filters also mean more pages fetched per surviving row.

What happens if a subreddit has no posts in the chosen window, or is private, quarantined or banned?

You get zero rows for that target and the run carries on with the next one — there is no error row to catch. The cases differ only in the log. An empty window, such as top / hour on a quiet subreddit, fetches fine and logs no posts found; done. A private, quarantined, banned or interstitial-gated community does not serve a listing to a logged-out client at all, and since the Actor sends no cookies and performs no login it cannot pass that gate: the page either fails the block check and is retried across fingerprints before the target is abandoned with a warning, or it comes back with no post elements and ends the same way. In code, treat "target produced no rows" as the signal, because nothing distinguishes these cases in the dataset itself.

Can I scrape multiple subreddits at once?

Yes. startUrls is a list and accepts as many targets as you like, mixing subreddits, usernames, search terms and full URLs in a single run. Every target gets the same sort, window and filters, and its own maxPosts allowance. What you cannot vary within one run is the sort and time window — those are single values, so two sorts means two runs.

Are posts that my filters reject still charged?

No. Charging is per saved row — one post_result event per post written to the dataset — and a post rejected by minUpvotes, minComments, includeNSFW or the keyword lists is discarded before the push. The same goes for promoted rows, which are dropped at parse time. The trade-off is time rather than money: rejected posts were still fetched, so aggressive filters make the Actor page deeper to reach maxPosts.

Does Reddit Trends Scraper work with Claude, ChatGPT and other AI agent tools, and is the output LLM-ready?

Yes to both. It is callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n or a hand-written tool definition can invoke it and receive typed, normalized JSON with consistent field names across runs — no HTML parsing, no selectors, no "48.2k" strings to clean up. Pass a row straight into a context window, index it into a vector store, or hand it to an agent tool. Deduplicate on postId first so an agent does not summarise the same post twice.

How does Reddit Trends Scraper compare to other trends scrapers on the Store?

Checked on the Apify Store on 25 July 2026: the most-used Actors matching a "trends" search cover other platforms, not Reddit. vnx0/google-trends-scraper documents Google's "Trending Now" feed with query, approxTraffic, trafficValue, a computed 1–1000 score, newsItems and up to 90 days of backfill; its listing states Google offers no official API for daily trending searches. easyapi/google-realtime-trends-data-scraper documents four output fields — country, keywordsText, lastUpdate, scrapedAt — with a country's trends collapsed into one comma-separated string. fastcrawler/twitter-x-trends-scraper-api-real-time-trend-tracker documents a single country input and rank, topic, tweet_volume, last_updated, noting that tweet_volume returns 0 when X hides it.

The observable difference is what the entity is. Those three return keyword or hashtag boards; this Actor returns individual Reddit posts with per-post engagement, subreddit context, flair and author, plus filters applied before anything is charged. Reddit has no keyword board to return in the first place, and none of the three cover Reddit at all. These are scope and field-list differences you can verify yourself — not performance claims.

What happens when Reddit changes its layout or anti-bot system?

The scraper is maintained, and your field names and types stay put regardless. The design already hedges against both risks: values are read from the data-* attributes Reddit renders on each post rather than from positional selectors or display text, so cosmetic redesigns generally pass through untouched, and a missing attribute degrades one field to null instead of corrupting the row. On the anti-bot side, the Actor rotates four browser TLS fingerprints and treats a suspicious 200 — a short body, or a block page — as a failure rather than as an empty result.

Can I use Reddit Trends Scraper without managing proxies or browser infrastructure?

Yes. Pick a proxy option in proxyConfiguration — it prefills to Apify residential, which is the setting to keep if Reddit rate-limits datacenter IPs — and the Actor draws a fresh proxy URL for every attempt on its own. You never create a proxy account, rotate an IP or run a browser: there is no headless browser here at all, just impersonated HTTP requests. Your selection is honoured exactly as given, including "no proxy", so the Actor never silently escalates you to a more expensive tier.

Which Reddit post fields work best for AI training data and RAG indexing?

For RAG indexing: title is the high-information text field, and it chunks best paired with flair and subreddit so a retrieved chunk carries its own topic and community rather than floating free — put postUrl in the chunk metadata as the citation. For training or modelling: upvotes, comments, createdAt, nsfw and subredditType are the structurally consistent fields across every record, with postId as the primary key. Bear in mind that upvotes is Reddit's fuzzed value at fetch time, so treat it as an engagement band rather than an exact label. All values return as typed primitives — integers, booleans, strings or null — so no normalization pass is needed before indexing.

🔗 Related scrapers

Scraper Name	What it extracts
Reddit Posts Scraper by Keyword & Score Filter	The same posts plus post body, images and a comments array — with keyword match modes (any / all / title-only / exact phrase), a minimum-score filter and optional in-subreddit search. Use it when you need what a post says; use this Actor when you need a fast, filtered listing snapshot with controversial sort, a minimum-comment filter or user targets
Reddit User Profile Posts and Comments Scraper with Account Age	Reddit from the account side — a user's posts and comments with karma, cake day, account age and account-quality filters
Twitter Trends Scraper	Trending topics on X with board rank and the board's real UTC snapshot hour
TikTok Trending Hashtags Scraper by Multiple Countries	Trending TikTok hashtags across several countries
Google News Scraper by Publisher Site Filter	News coverage filtered to a specific publisher or domain
Quora Search Scraper	Question-intent results on the same topics discussed on Reddit

💬 Your feedback

Found a bug, or need a field this listing row does not carry? Open an issue on the Actor's Issues tab. Reports that include the exact input JSON and the postUrl from the row that looked wrong are the fastest to reproduce and fix — and if what you actually need is post bodies or comments, say so in the issue, since that is the clearest signal for what to build next.