How to Detect Trending Topics on Reddit With an API

Detecting trending topics on Reddit means snapshotting the platform's ranked listings on a schedule and measuring what is accelerating: not what has the highest score, but what is gaining score and comments the fastest right now. It is a velocity calculation on top of a collection step. You poll GET https://api.redditapis.com/api/reddit/posts?subreddit=<name>&sort=hot and sort=rising at a fixed interval, store each post's engagement with a timestamp, and compare the new snapshot against the previous one to find the steepest climbers. This guide builds the whole thing with copy-paste Python: the snapshot call, the velocity math, the ranking that surfaces trending posts, the same idea applied to trending subreddits and emerging keyword topics, and the one data-layer decision that determines whether the poller keeps running in production.

Not affiliated with Reddit Inc. redditapis.com is an independent third-party REST API for Reddit data. This guide is vendor-neutral: it shows the snapshot, velocity, and ranking steps honestly, names the official Reddit API and open-source tooling where they fit, and points at the ranking math so you can build the pieces that suit your situation.

---

TL;DR: Trending is a rate of change, so you snapshot and compare. (1) Poll GET https://api.redditapis.com/api/reddit/posts?subreddit=<name>&sort=hot and sort=rising on a fixed interval with a Bearer key. (2) Store each post's upvotes and comment count with a timestamp. (3) Compute velocity: (upvotes_now - upvotes_before) / minutes_elapsed for score and comments. (4) Rank by velocity, not absolute score, to surface what is accelerating; normalize with a z-score to compare across subreddits of different sizes. The same snapshot-and-compare finds trending subreddits (via sub/<name>/about) and emerging topics (via keyword search sorted by new). Cost scales with polling frequency at about $0.002 a call. The one decision that decides whether it survives production is the data layer, because a raw call to Reddit from a server returns 403 from most datacenter IPs. The first $0.50 is free at /signup.

---

What this guide covers:

• What trend detection on Reddit is, and why the API beats watching the homepage
• The three trend signals: score velocity, comment velocity, and new-post volume
• Step 1: snapshotting hot, rising, and top, with working Python
• Step 2: computing velocity between snapshots, and Step 3: ranking and surfacing
• Detecting trending subreddits and emerging keyword topics
• The data-layer decision, the cost math, and the honest limitations

---

What Is Trend Detection on Reddit?

Trend detection on Reddit is finding what is gaining attention fastest right now by measuring the rate of change of engagement, not its absolute level. A post with 5,000 upvotes accumulated over a day is popular; a post gaining 300 upvotes in the last ten minutes is trending, and trend detection is the machinery that tells the two apart. The output is a ranked list of accelerating posts, subreddits, or topics, updated every time you poll.

Trending is about acceleration, not altitude: a post gaining fast beats a higher-scoring post that has stalled, which is why velocity is the signal

People build this for launch monitoring, catching a breaking story in a niche before it hits the front page, spotting a competitor's post gaining traction, or feeding a content or trading pipeline that reacts to what a community is talking about. All of them are the same calculation pointed at different listings, and all of them need the same thing the Reddit homepage cannot give you: a stored history to measure change against.

Why the API, Not the Homepage

You detect trends through the API rather than by watching the homepage because trending is a rate of change, and a rate of change needs a stored history that a web page does not keep. Reddit's hot and rising tabs show you a single moment; to know that a post is accelerating you have to compare this moment against the last one, which means capturing structured snapshots on a schedule and diffing them. That is exactly what an API gives you and a browser does not.

The demand for this is real, developers keep building trend trackers on top of Reddit because the signal is genuinely useful.

r/

r/SideProject·u/dataneedscoffee

I built a free tool that tracks stats and monthly trends across 100,000+ subreddits

00

Open on Reddit

That project tracks stats and monthly trends across 100,000 subreddits, which is snapshot-and-compare at scale. An API-driven approach buys three things the homepage cannot:

• History: stored snapshots you can diff, which is the only way to compute velocity
• Breadth: many subreddits and searches polled in parallel, not one page at a time
• Structure: clean numeric fields (upvotes, comment counts) you can do math on directly

The rest of this guide is the concrete build: what to snapshot, how to turn two snapshots into a velocity, and how to rank the result so the genuinely trending items rise to the top.

The Signals: Score Velocity, Comment Velocity, and Volume

Three signals tell you something is trending, and the strongest detectors combine them: score velocity, comment velocity, and new-post volume. Each catches a different shape of trend, and using them together filters out the false positives that any one alone would surface.

Three signals, three shapes of trend: a post accelerating in score, a thread exploding in comments, and a topic spiking in fresh-post volume across the platform

What each signal catches:

• Score velocity: how fast a post's upvotes are climbing. Catches a single post breaking out.
• Comment velocity: how fast a thread's comment count is climbing. Catches a controversy or a discussion catching fire, which sometimes moves before score does.
• New-post volume: how many fresh posts mention a keyword in a short window versus the baseline. Catches a topic trending across the platform rather than one post trending within a subreddit.

The first two are per-post and come from snapshotting listings; the third is per-topic and comes from keyword search sorted by new. The next sections build the per-post velocity first, because it is the core calculation everything else reuses.

Step 1: Snapshot Hot, Rising, and Top

The snapshot step captures the current state of a subreddit's listings so you have something to compare against next time. You poll hot and rising for the live picture and top?t=day for a baseline, reading each post's upvotes, comment count, and id. Here is the snapshot against a REST endpoint with a Bearer key:

import os, time, requests

API_KEY = os.environ.get("REDDIT_API_KEY", "YOUR_API_KEY")  # free key at redditapis.com/signup
BASE = "https://api.redditapis.com/api/reddit"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def snapshot(subreddit: str, sort: str = "hot", limit: int = 50) -> dict[str, dict]:
    """Current listing keyed by post id, with the fields velocity needs."""
    r = requests.get(f"{BASE}/posts",
                     headers=HEADERS,
                     params={"subreddit": subreddit, "sort": sort, "limit": limit},
                     timeout=20)
    r.raise_for_status()
    now = time.time()
    return {
        p["id"]: {
            "title": p["title"], "subreddit": p["subreddit"],
            "upvotes": p["upvotes"], "num_comments": p["num_comments"],
            "permalink": p["permalink"], "t": now,
        }
        for p in r.json().get("posts", [])
    }

if __name__ == "__main__":
    snap = snapshot("technology", sort="rising")
    print(f"captured {len(snap)} posts at one instant")

The sort values hot, rising, top, and new are all supported on GET /api/reddit/posts, and top accepts a t window (hour, day, week, and so on). Read upvotes and num_comments off each row because those are the numeric fields the posts response carries, and keep the poll limit modest so a snapshot is one cheap call. For the listing sorts and their parameters in full, the subreddit analytics comparison and the data API overview cover the surface, and the Node.js guide shows the same in TypeScript.

Step 2: Compute Velocity Between Snapshots

Velocity is the change in engagement between two snapshots divided by the time elapsed, and it is the calculation that turns two flat listings into a trend signal. You keep the previous snapshot, and on the next poll you match posts by id and compute the per-minute rate of change for score and comments. Here is the diff:

def velocity(prev: dict[str, dict], curr: dict[str, dict]) -> list[dict]:
    """Per-post score and comment velocity between two snapshots."""
    out = []
    for pid, now in curr.items():
        before = prev.get(pid)
        if not before:
            continue  # new since last poll; needs one more snapshot to rate
        minutes = max((now["t"] - before["t"]) / 60.0, 1e-6)
        out.append({
            "id": pid,
            "title": now["title"],
            "subreddit": now["subreddit"],
            "permalink": now["permalink"],
            "score_velocity": (now["upvotes"] - before["upvotes"]) / minutes,
            "comment_velocity": (now["num_comments"] - before["num_comments"]) / minutes,
        })
    return out

The match-by-id step is what makes this correct: the same post appears in both snapshots, so subtracting its old score from its new one gives the true gain, and dividing by the elapsed minutes normalizes for an uneven polling interval. A post that is new since the last poll has no prior to rate against, so it waits one more cycle rather than being scored off a single point. Run snapshot on a schedule, keep the last result, and feed both into velocity each cycle. The scheduled-polling loop and its storage are the same machinery as a Reddit keyword monitor, with this velocity step added on top.

Step 3: Rank and Surface Trending Posts

Ranking turns per-post velocities into the short list you actually surface, and the one correction that matters is normalizing across subreddits of different sizes. A raw score velocity favors big subreddits where everything moves fast, so a genuinely trending post in a small community gets buried. Normalizing each post's velocity against its subreddit's typical rate, for example as a z-score, fixes that: it measures how unusual this post's acceleration is for its own community.

Normalizing velocity by each subreddit's typical rate is what lets a breakout in a small community outrank routine motion in a big one

The ranking is a sort on the normalized velocity:

import statistics

def rank_trending(rows: list[dict], baseline: dict[str, list[float]], top_n: int = 10):
    """Rank by how unusual each post's score velocity is for its subreddit."""
    scored = []
    for r in rows:
        hist = baseline.get(r["subreddit"], [])
        if len(hist) >= 5:
            mean = statistics.mean(hist)
            sd = statistics.pstdev(hist) or 1.0
            r["z"] = (r["score_velocity"] - mean) / sd   # standard score
        else:
            r["z"] = r["score_velocity"]                 # not enough history yet
        scored.append(r)
    return sorted(scored, key=lambda x: x["z"], reverse=True)[:top_n]

The baseline is a rolling history of recent velocities per subreddit that you accumulate as you poll, so the z-score gets more accurate the longer the tracker runs. The output is a ranked list where the top entries are the posts accelerating most unusually for their community, which is the definition of trending you actually want. Developers build exactly this kind of ranked, momentum-based Reddit view.

r/

r/options·u/likevinli

I built a Reddit-powered “Bloomberg terminal” to track ticker trends and identify bull/bear cases

00

Open on Reddit

That project ranks tickers by Reddit momentum, which is this same velocity-and-rank pipeline pointed at a set of keywords instead of a set of subreddits.

Detecting Trending Subreddits, Not Just Posts

The same snapshot-and-compare approach finds trending communities, not just trending posts, by watching each subreddit's own activity over time. You poll GET /api/reddit/sub/<name>/about for the communities you track and store subscribers and active_user_count with a timestamp; a subreddit whose active-user count or subscriber growth accelerates is a community trending as a whole. To discover which communities to watch in the first place, a community search returns subreddits matching a topic with their sizes.

Two levels of trend: posts accelerating inside a community, and the community itself accelerating, and watching both catches a topic and the crowd forming around it

The subreddit-level snapshot mirrors the post-level one:

def community_snapshot(name: str) -> dict:
    r = requests.get(f"{BASE}/sub/{name}/about", headers=HEADERS, timeout=20)
    r.raise_for_status()
    d = r.json()
    return {"name": d["name"], "subscribers": d["subscribers"],
            "active": d.get("active_user_count"), "t": time.time()}

def discover(topic: str, limit: int = 25) -> list[dict]:
    r = requests.get(f"{BASE}/search/communities",
                     headers=HEADERS, params={"q": topic, "limit": limit}, timeout=20)
    r.raise_for_status()
    return [{"name": c["name"], "title": c["title"], "subscribers": c["subscribers"]}
            for c in r.json().get("communities", [])]

Combining rising post velocity inside a subreddit with rising activity of the subreddit itself gives a two-level picture: the topic that is heating up and the community forming around it. Discovering the right communities to watch is its own task, and the how to find subreddits guide covers the discovery side in depth.

Emerging Topics: New-Post Volume Across the Platform

The third signal catches a topic trending across Reddit rather than one post trending within a subreddit, and it comes from watching how many fresh posts mention a keyword in a short window versus the baseline. You search for the keyword sorted by new, count the posts in the last window, and compare that count against the recent average; a window that is well above the baseline is an emerging topic. This is the same z-score idea applied to post counts instead of scores.

def new_post_volume(keyword: str, window_min: int = 60) -> int:
    """Count fresh posts mentioning a keyword in the recent window."""
    r = requests.get(f"{BASE}/search",
                     headers=HEADERS,
                     params={"q": keyword, "sort": "new", "t": "day", "limit": 100},
                     timeout=20)
    r.raise_for_status()
    cutoff = time.time() - window_min * 60
    posts = r.json().get("posts", [])
    return sum(1 for p in posts if p.get("created_utc", 0) >= cutoff)

Store the per-window count each poll, keep a rolling baseline, and flag a window whose count exceeds the mean by a couple of standard deviations. This is the signal that catches a breaking story or a viral product moment while it is still small, before any single post has accumulated enough score to reach hot. Reddit's own listing sorts are a single moment; building your own volume baseline is what turns that moment into a rate. Developers keep asking for exactly this kind of real-time, engagement-filtered Reddit access.

Om Patel

@om_patel5

REDDIT API IS BACK. I just launched a Reddit MCP tool that lets you search Reddit in real time from any AI client. > search posts across any subreddit by keyword, time, and engagement > pull full comment threads from any post > fetch top posts from any subreddit with f… Show more

The pattern in that post, searching Reddit in real time and filtering by engagement across subreddits, is the collection layer every signal in this guide sits on top of.

The Data Layer Decision: What the Poller Calls

The single decision that determines whether a trend detector survives production is what the poller calls underneath: Reddit's raw OAuth API, the PRAW wrapper, or a managed REST endpoint. The velocity and ranking code is identical in all three cases; only the data layer changes, and because trend detection is defined by tight, frequent polling, the rate budget and the datacenter block bite harder here than in almost any other Reddit workload.

The velocity code is the same across all three data layers; a managed REST endpoint trades a small per-call fee for the datacenter reliability and rate headroom tight polling needs

The honest comparison:

Data layer	Setup	Reliability under frequent polling	Rate headroom	Cost model
Raw Reddit OAuth API	OAuth app, token refresh	Frequent 403 from cloud IPs	Per-token budget, tight	Free tier then usage tiers
PRAW wrapper	OAuth app plus PRAW	Frequent 403 from cloud IPs	Per-token budget, tight	Free tier then usage tiers
Managed REST endpoint	Bearer key, one header	Accepted IP pool	Usage-scaled	Per-call usage fee

If the tracker only ever runs on your own machine and polls a couple of subreddits slowly, the raw API or PRAW is fine. But a trend detector by definition polls often, from a server, across many listings, and that is exactly where a direct call to Reddit returns 403 Forbidden from most datacenter IPs and where a per-token rate budget runs out fastest. A managed endpoint whose IP pool Reddit accepts removes both failure modes, and the rate limits guide and the PRAW versus REST comparison lay out the trade. Full endpoint behavior, headers, and error codes are in the API documentation.

What It Costs to Run a Trend Detector

Running a Reddit trend detector costs whatever the poller charges per call, and the polling interval is the main lever. Trend detection is snapshot-and-compare, so cost scales with how many listings you snapshot and how often, not with a per-seat subscription: tighter intervals catch faster trends but spend more calls.

Cost scales with polling frequency and breadth, not seats, so a few subreddits every fifteen minutes is a few dollars and a broad fast poller is still modest

The rough monthly math at about $0.002 per call:

• Light (a few subreddits every fifteen minutes): roughly $4 a month
• Regular (a dozen subreddits and searches every few minutes): roughly $12 a month
• Heavy (dozens of listings polled every minute or two): roughly $35 a month

The planning move is to count calls: multiply listings per poll by polls per hour by hours per month by the per-call price, then pick the loosest interval that still catches the trends you care about. Model your own numbers with the Reddit API cost calculator and the pricing page; the first $0.50 of credit is free at signup. For a side-by-side of what providers charge per call, the pricing ranked comparison puts the numbers together.

Building Responsibly, and the Honest Limits

A Reddit trend detector is a read-only polling tool, and running one responsibly means respecting the platform's rate expectations and being honest about what a spike means. Polling public listings to measure velocity is low-stakes, but a few limits are worth stating plainly:

• Poll at a sane interval: tighter is not always better, and hammering an endpoint is both wasteful and rude to any data layer; pick the loosest interval that catches your trends.
• A spike can be manufactured: brigading and coordinated pushes produce the same velocity signature as organic momentum, so read a trending item alongside its actual posts before acting on it.
• The public index is broad but not exhaustive: a listing returns what Reddit surfaces, which is most of the live picture but not every removed or filtered post.
• Velocity is noisy at the edges: a post with tiny absolute numbers can show a huge percentage velocity, so apply a minimum-engagement floor before ranking.

The legal footing of pulling Reddit data through an API, distinct from collecting it off web pages, is covered in the is it legal to collect Reddit data guide, and Reddit's developer API terms are the reference for what programmatic access is expected to look like.

The Bottom Line

Detecting trending topics on Reddit is snapshot-and-compare: poll hot, rising, and top on a schedule, store each post's upvotes and comment count with a timestamp, compute velocity as the change divided by the elapsed time, and rank by that velocity rather than by absolute score. Normalize with a z-score so a breakout in a small community is not buried by routine motion in a big one, and apply the same snapshot-and-compare to subreddit activity and to keyword post-volume to catch trending communities and emerging topics. Cost scales with your polling interval at about $0.002 a call, so a focused tracker is a few dollars a month. The one decision that decides whether it survives production is the data layer underneath the poller, because a raw call to Reddit from a server returns 403 from most datacenter IPs and a per-token budget runs out fast under tight polling, so point the poller at an endpoint with an accepted IP pool. If you are building the pieces, the subreddit analytics comparison, the keyword monitor, and the how to find subreddits guide are the neighbors, and how to do Reddit sentiment analysis is the feeling-side sibling of this attention-side guide. Grab a free key and start detecting trends.