Most Popular Subreddits via the Reddit API: Trending and Hot Communities in 2026

"Most popular subreddits" sounds like it should be one API call that returns a ranked list, and it almost is, but the ranking you get back is probably not the one you expected. This guide shows how to pull the popular, trending, and hot communities on Reddit programmatically, why the popular ranking diverges hard from the subscriber ranking, and how to assemble the leaderboard most people actually want, with code you can run against a live endpoint.

TL;DR: Reddit's popular-subreddits listing is served at GET https://api.redditapis.com/api/reddit/subreddits/popular and returns a subreddits array ordered by current activity, not by size. In a live pull on 2026-08-02 the top slot was r/Home at about 422,000 subscribers, ranked above r/funny at about 67.5 million, because "popular" measures what is busy right now. For the biggest communities you sort by the subscribers field; for topic-specific communities you search with search/communities and rank the results yourself; for the hot posts inside a community you read sub/{name}/top. No live endpoint stores growth history, so a real fastest-growing leaderboard is something you snapshot over time. The honest split is: the official Reddit API and PRAW are free and authoritative but OAuth-gated and rate-limited, while a hosted REST API like redditapis.com trades the OAuth flow for a bearer token and is the low-maintenance path for building a live subreddit ranking across many communities.

If you searched for "most popular subreddits" you have seen the same results everyone does: static listicles ranking communities by subscriber count, such as the Visual Capitalist ranking of the largest communities on Reddit, a couple of dashboard tools, and forum threads asking which subreddits are most active. None of them shows a developer how to pull the data live. That is the gap this guide fills. It sits alongside how to find subreddits via the API, the subreddit analytics comparison, and how to detect trending topics on Reddit, which cover discovery, per-community stats, and velocity in more depth.

What does "most popular subreddits" mean via the Reddit API?

"Most popular subreddits" is not one metric, it is a family of them, and choosing the wrong one gives you a defensible-looking list that answers a question you did not ask. There are three distinct rankings hiding under the phrase, and each maps to a different call:

• Size: the biggest communities, read from the subscribers count. Only ever trends up.
• Live popularity: the busiest communities right now, the order the popular listing returns. Swings daily.
• Topical relevance: the best communities for a subject, which no endpoint ranks for you, so you search and sort them yourself.

Before you write a line of code, decide which of the three you mean, because each returns a different order.

The reason this matters is that the three lists genuinely disagree. A community can be enormous and quiet, or small and on fire, and "popular" rewards the second while "biggest" rewards the first. Getting programmatic Reddit data at all has become the harder half of the problem since self-service access tightened, which is why builders reach for wrappers that skip the approval queue:

Granite

@Granite0x

🤯 YOUR AGENT NOW READS THE ENTIRE INTERNET WITHOUT A SINGLE API KEY someone open-sourced this repo. it replaces $300/mo in paid APIs Agent Reach. #1 Repository of the Day on GitHub trending. 63,165 stars install it - and your agent reads: - any web page → clean markdown - ht… Show more

Once you can call the endpoints, the ranking question is the interesting one. The rest of this guide walks each of the three definitions, shows the endpoint that serves it, and ends by assembling them into the leaderboard most people picture when they say "top subreddits."

Which Reddit API endpoints return popular and trending subreddits?

Four endpoints cover community discovery, and knowing which one answers which question saves you from forcing a single call to do a job it was not built for. The popular listing returns communities ordered by current activity. The default listing returns Reddit's curated front-page set, the communities a logged-out visitor sees. The new listing returns the most recently created communities. And community search returns communities matching a keyword, ordered by relevance. On a hosted REST API these are GET /api/reddit/subreddits/popular, /subreddits/default, /subreddits/new, and /search/communities, each returning a JSON array plus an after cursor. The official Reddit API exposes the same data through its listing endpoints at /subreddits/popular, /subreddits/default, /subreddits/new, and /subreddits/search.

There is a fifth, narrower surface worth naming so you do not go hunting for it: Reddit's own trending_subreddits endpoint, which returns a small, daily-curated handful of communities Reddit is spotlighting. Developers have asked how to consume it for years, as in this r/redditdev thread on the trending_subreddits endpoint. It is real, but it is an editorial pick of a few names, not a data-driven ranking, so treat it as a curiosity rather than the backbone of a leaderboard.

One capability that used to exist and no longer does is worth flagging, because you will find it in old tutorials. PRAW removed subreddits.search_by_topic and the random-subreddit helpers in its version 8 release, documented in the PRAW 8 change log. If a Stack Overflow answer tells you to call search_by_topic, it is stale. Topic discovery now goes through community search, which is covered below.

How is "popular" ranked: popularity versus subscriber count

Reddit's popular listing is ordered by live activity, not by subscriber count, and this is the single most misunderstood thing about it. The endpoint returns communities in the order Reddit currently considers most popular, a blend of recent posting, voting, and viewing that shifts through the day. It does not return them sorted by size, so if you read the array in order and assume the first entry is the biggest community, you will be wrong most of the time. The subscriber count is present on every entry, but you have to sort by it yourself to get the "biggest communities" list.

How far apart are the two orders? Very. Here is the top of a live popular pull on 2026-08-02, next to each community's actual subscriber count.

The number one slot was r/Home, with about 422,000 subscribers. Sitting below it in the same pull were r/AskReddit at about 59.3 million and r/interestingasfuck at about 16.7 million, communities dozens of times larger. Further down the same listing, r/funny, the single biggest community on the platform at about 67.5 million subscribers, appeared around the fifteenth position. Read the popular order literally and a community 160 times smaller than r/funny outranked it, because at that moment r/Home was busier. That is the endpoint working correctly. It is answering "what is active now," and activity is not size.

So the rule is simple and you should hard-code it into your mental model: to rank by popularity, read the listing order the API gives you and do not re-sort. To rank by size, ignore the order and sort by the subscribers field. Mixing the two, sorting a "popular" pull by subscribers and calling the result popular, produces the static top-communities list every listicle already publishes, which is a fine artifact but is not what the popular endpoint is for. The subreddit analytics comparison goes deeper on reading size and momentum as separate signals.

How to get the most popular subreddits (with code)

Getting the popular listing is one authenticated GET. On a hosted REST API you send a bearer token and read the subreddits array back; there is no OAuth dance and no app registration to manage. The function below was executed against the live API while writing this guide. It pulls the current popular communities and prints each one's name and subscriber count, using the requests library.

import requests

BASE = "https://api.redditapis.com"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY"}

def popular_subreddits(limit=30):
    """Pull the current most-popular subreddits, in Reddit's live popularity order."""
    resp = requests.get(
        f"{BASE}/api/reddit/subreddits/popular",
        params={"limit": limit},
        headers=HEADERS,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json().get("subreddits", [])

subs = popular_subreddits(limit=10)
for i, s in enumerate(subs, 1):
    print(f"{i:>2}. {s['display_name_prefixed']:<22} {s['subscribers']:>12,}")

Each entry in the array carries display_name_prefixed, name, subscribers, subreddit_type, over_18, and created_utc, which is enough to build a ranked table or filter out communities you do not want. The after field in the response is a cursor: pass it back as the after parameter on the next call to page forward, keeping in mind the listing cap discussed later. For the official Reddit API, the same list lives at /subreddits/popular.json behind an OAuth token; see the Reddit OAuth and authentication guide for the token flow and how to get a Reddit API key for registration.

If you want the biggest communities instead of the busiest, keep the same call and change one line: sort the returned array by subscribers in descending order before you print it. That flips a live-popularity pull into a size ranking without a second request, because the subscriber count rides along on every entry. The distinction is the whole point of the previous section, so make it explicit in your code with a variable name like by_activity or by_size rather than a bare subs.

How to find trending subreddits

Trending is the definition people ask for most and the one no endpoint hands you cleanly, so it pays to be precise about what you can and cannot get. Reddit's native trending_subreddits endpoint returns a short, editorially curated list of a few communities per day, useful as a spotlight but not a ranking. Everything richer than that, a fastest-growing leaderboard, a "rising communities this week" list, you build yourself by snapshotting the popular and new listings on a schedule and measuring the change between snapshots. The reason is structural: every live listing is a point-in-time reading, and none of them stores yesterday's numbers, so growth is something you have to accumulate rather than request.

The demand for a real trend view is old and consistently unmet, as in this r/redditdev thread asking for updated Reddit trend analysis, where the poster notes that r/popular and the various stats sites only surface individual hot submissions, not communities trending across many posts. The workable pattern is a two-snapshot velocity calculation: store each community's subscriber count and post volume today, read them again tomorrow, and rank by the delta.

The finding people want to sell you as "trending" is really a demand signal, and it lives in specific communities rather than in the aggregate. Operators who work Reddit for real do not watch a global trending list, they watch a handful of subreddits in their niche and act on the fresh posts:

James Shields

@scaling_shields

met a guy making $51,000/month by scraping reddit for the phrase "anyone got recommendations for" and emailing the posters within 2 hours not joking he opens reddit every morning runs a search on 8 subreddits in his niche finds people who just publicly asked for exactly what he

That is the practical version of trend detection: pick the communities that matter for your subject using community search, then watch their new and rising posts. The full velocity method, including how to normalize a fast post in a small community against a large one, is in how to detect trending topics on Reddit, and the Reddit keyword monitor walkthrough extends it to keyword-level alerts.

How to get the hot posts of a subreddit

Once you know which communities matter, the next question is what is hot inside them, and that is a ranked post listing rather than a subreddit listing. On a hosted REST API you call GET /api/reddit/sub/{name}/top with a time window; the official API exposes the same data at /r/{subreddit}/hot, /top, and /rising. The three sorts answer different questions: hot blends score with recency for what is popular right now, top ranks by raw score within a window such as t=week, and rising surfaces posts gaining engagement unusually fast for their age. For a "hottest posts" view, hot or top?t=day is the right call.

def subreddit_top(name, t="week", limit=10):
    """Pull the top posts of a subreddit for a time window."""
    resp = requests.get(
        f"{BASE}/api/reddit/sub/{name}/top",
        params={"t": t, "limit": limit},
        headers=HEADERS,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json().get("posts", [])

for p in subreddit_top("AskReddit", t="week", limit=5):
    print(f"{p['upvotes']:>7,} up  {p['comments']:>6,} com  {p['title'][:54]}")

In a live pull of r/AskReddit's top of the week on 2026-08-02, the leading post carried about 17,000 upvotes and 10,700 comments, and a book-recommendation thread further down had about 8,700 upvotes but nearly 22,000 comments, a reminder that upvotes and comments measure different things and a "hottest" ranking should decide which one it means. Each post carries upvotes, comments, upvote_ratio, title, permalink, and created_utc, which is everything you need to rank posts within a community or compare activity across communities.

A tutorial that walks pulling a subreddit's posts and turning them into an analysis end to end is a useful companion here, even though its specific subject is incidental:

When you rank posts by engagement, use the median rather than the mean if you are summarizing a community, because a handful of viral posts pull the average far above what a typical post earns. The median is the honest default for skewed social data. The Reddit search API tutorial and advanced search filters cover filtering these same listings by keyword and flair.

How to search communities by topic

There is no endpoint that returns "the most popular subreddits about machine learning," so topical popularity is a search-and-sort job, not a lookup. Developers have asked for a subreddit-popularity ranking endpoint for years, as in this Stack Overflow thread on subreddit statistics, and the honest answer has always been that you assemble it yourself. You query community search with a keyword and get back the communities that match, ordered by Reddit's relevance ranking, then you sort those results by subscriber count yourself if you want the biggest ones. On a hosted REST API that is GET /api/reddit/search/communities.

def search_communities(q, limit=10):
    """Find communities matching a topic, ranked by relevance."""
    resp = requests.get(
        f"{BASE}/api/reddit/search/communities",
        params={"q": q, "limit": limit},
        headers=HEADERS,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json().get("communities", [])

for c in search_communities("artificial intelligence", limit=10):
    print(f"{c['display_name_prefixed']:<24} {c.get('subscribers', 0):>12,}")

Community search has two quirks that will bite you if you trust the raw results, and both showed up in a live query for "artificial intelligence" on 2026-08-02. First, the results are relevance-ranked, not size-ranked: the top hit was r/ArtificialInteligence at about 1.9 million subscribers, above r/Futurology at about 21.7 million, which matched the query less tightly but is far larger. Second, the results include near-duplicate misspelled communities (r/ArtificialInteligence, r/ArtificialNtelligence, r/ArtificalIntelligence are three different subreddits) and the occasional off-topic giant that merely mentions the term (r/Showerthoughts at about 34 million matched). If you are building a "top communities for a topic" list, deduplicate on name similarity and filter by a subscriber floor before you present the ranking.

The practical recipe is: search, deduplicate, apply a subscriber floor, then sort by whichever axis you care about. That turns a noisy relevance list into a clean topical ranking. For a full walkthrough of discovery, including the default and new listings, see how to find subreddits via the API, and for the r/findareddit and r/newtoreddit angle on human-curated discovery, the same guide covers where the API stops and community knowledge begins.

How to read a subreddit's size and momentum

Every ranking eventually needs per-community numbers, and those come from the about record, which is the closest thing to a stats endpoint Reddit exposes. On a hosted REST API it is GET /api/reddit/sub/{name}/about, and it returns the community's subscribers count, creation date, type, and descriptive fields. Read it for any subreddit you surfaced from the popular, default, or search listings when you need the exact size rather than the rounded figure in a listing entry.

def subreddit_about(name):
    """Fetch a subreddit's about record: subscribers, type, creation date."""
    resp = requests.get(
        f"{BASE}/api/reddit/sub/{name}/about",
        headers=HEADERS,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()

about = subreddit_about("AskReddit")
print("subscribers:", about["subscribers"])
print("active now:", about.get("active_user_count"))
print("created:", about["created"])

There is a current caveat you must design around. The live active-user count, historically the active_user_count field, has become unreliable. In a live about pull on 2026-08-02, r/AskReddit returned about 59.3 million subscribers but a null active-user count, and developers on r/redditdev have reported the attribute disappearing from their PRAW code with no changelog, as in this thread about the active_user_count attribute vanishing. Separately, after Reddit stopped showing subscriber counts on parts of its own site, developers asked whether the field would survive in the API at all:

r/

r/redditdev·u/stummj

Is subscriber count staying in the Subreddit-related endpoints?

00

Open on Reddit

The subscriber count is still returning through the API today, which is the dependable size signal to rank on. The live active count is the one to treat as best-effort: read it if present, but do not make a leaderboard depend on it. This is exactly the point-in-time-versus-history problem the subreddit analytics comparison covers, and the reason growth tracking needs your own snapshots.

How far can you page: listing caps and rate limits

You cannot page the popular listing forever, and assuming you can is a common way to build a ranking that silently truncates. Reddit's listing responses have been shrinking. Developers on r/redditdev report the per-listing item cap falling from 1,000 to 250 and, more recently, to around 100, with the after cursor returning empty results sooner than it used to:

r/

r/redditdev·u/adambyle

Listing size decrease?

00

Open on Reddit

What that means in practice is that the popular and default listings reliably give you the head of the distribution, the communities that actually matter for most rankings, but not a complete index of every subreddit on the platform. If you need broad coverage you search by topic in slices and stitch the results, accepting overlap and gaps, rather than expecting one listing to page through the entire tail.

Rate limits bound how fast you can poll all of this. The official Reddit API sits at roughly 100 queries per minute averaged over a ten-minute window per authenticated client, which is your ceiling across every call, and the Reddit Data API terms separate free non-commercial use from paid commercial tiers, with the budget documented in the Reddit Data API Wiki. A hosted REST API moves the rate-limit backoff server-side so you are not writing 429 handling yourself, but the underlying budget is the same Reddit budget. See the Reddit API rate limits breakdown and pagination guide for how many communities you can realistically poll before the budget bites.

Building a live "popular subreddits" leaderboard in 2026

Put the pieces together and the leaderboard most people picture is a short pipeline rather than a single call. You pull the popular listing for the live activity order, read each community's about record for the exact subscriber count, optionally join a topic filter from community search, and present two columns, one ranked by activity and one ranked by size, so a reader can see both. The whole thing runs on the endpoints above and refreshes as fast as your rate budget allows.

The pipeline is four steps:

• Pull the popular listing for the live activity order.
• Read each about record for the exact subscriber count.
• Join a topic filter from community search when you want a subset.
• Present two columns, one by activity and one by size, so the gap is visible.

def leaderboard(limit=15):
    """Combine the live popular order with exact subscriber counts."""
    subs = popular_subreddits(limit=limit)
    rows = []
    for rank, s in enumerate(subs, 1):
        rows.append({
            "popularity_rank": rank,
            "name": s["display_name_prefixed"],
            "subscribers": s["subscribers"],
        })
    by_size = sorted(rows, key=lambda r: r["subscribers"], reverse=True)
    return rows, by_size

by_activity, by_size = leaderboard(limit=15)
print("Top by live activity:", [r["name"] for r in by_activity[:5]])
print("Top by subscribers:  ", [r["name"] for r in by_size[:5]])

The value of presenting both columns is that it makes the popularity-versus-size gap visible instead of hiding it behind a single number. In a live run the activity column led with communities like r/Home and r/NoStupidQuestions, while the size column led with r/funny, r/AskReddit, and r/gaming, and the two orders barely overlapped at the top. A reader who only saw one column would draw the wrong conclusion about which communities are "the most popular," which is the exact confusion this guide exists to remove.

To keep the leaderboard fresh you rerun it on a schedule and store each run, which also gives you the snapshots you need for the trending calculation from earlier. That is the same collect-then-compute pattern behind webhooks versus polling for Reddit data streams and the reason a managed endpoint that absorbs the OAuth and backoff work pays off once you are polling many communities on a cadence. For teams feeding this into a model or agent, the Reddit API for AI agents guide and Reddit as a RAG data source cover the downstream shape.

Common mistakes ranking subreddits via the API

The failure modes here are predictable and they all come from treating one metric as if it were the only one. The biggest is reading the popular listing in order and calling it a size ranking, when it is an activity ranking, so a small busy community outranks a giant quiet one and your "top subreddits" list looks broken to anyone who knows the platform. The second is trusting community-search order as a popularity ranking, when it is relevance-ranked and salted with misspelled clones and off-topic giants. The third is building on the live active-user count, which is currently unreliable, instead of the dependable subscriber count. The fourth is assuming you can page a listing to the end, when the cap now truncates you to the head of the distribution.

The fixes are the through-line of this whole guide: decide which of the three rankings you mean before you call anything, sort by the subscribers field when you want size and read the given order when you want activity, deduplicate and floor community-search results before presenting them, treat the active count as best-effort, and design for a head-of-distribution listing rather than a full index. None of it is exotic, but skipping any of it produces a ranking that quietly misleads.

The verdict

"Most popular subreddits" is a question with three honest answers, and the API serves each one differently. For live popularity, read the popular listing in the order it returns and do not re-sort. For the biggest communities, take the same data and sort by the subscribers field. For topical popularity, search communities by keyword, then deduplicate, floor, and sort the results yourself. For what is hot inside a community, read its top or hot post listing, and for a real fastest-growing view, snapshot the listings over time and rank by the change, because no live endpoint keeps history.

The endpoints are the easy part once you can call them: the popular, default, new, community-search, top, and about surfaces cover everything above, and a hosted REST API like the one whose functions are live in this guide serves them over a single bearer token so you skip the OAuth app and the rate-limit bookkeeping. Start with the authentication guide, wire up how to find subreddits, or grab an API key and point popular_subreddits at the live listing to see today's ranking for yourself.

redditapis.com is an independent third-party service and is not affiliated with, endorsed by, or sponsored by Reddit Inc. This guide reflects the publicly documented Reddit API state and live pulls as of August 2026; verify current fields, listing caps, and pricing against Reddit's developer documentation and /pricing before you build.