Advanced Reddit Search Filters API (2026)

Reddit's search endpoint answers a keyword query, but it will not let you ask for only the high-signal posts. You cannot tell native search "give me posts above 500 upvotes" or "only text self-posts" or "sorted by comment count." The advanced filters API closes that gap: it takes the page Reddit returns and applies score, comment-count, media, and state filters to it, the same way pullpush did for historical data. This guide covers every filter parameter, the honest completeness meta, and copy-paste Python.

Not affiliated with Reddit Inc. redditapis.com is an independent third-party REST proxy for Reddit's API. This guide is vendor-neutral: it explains the native /search.json limits, the pullpush filter model, and a managed REST option so you can pick what fits.

---

TL;DR: Reddit's search cannot filter by score, comment count, or media type server-side. A managed endpoint applies those filters to the returned page, like pullpush: pass min_score, max_comments, is_self, is_video, over_18, or sort_type to https://api.redditapis.com/api/reddit/search with your q. A filtered response adds a meta block (fetched, returned, filtered_out) so a small page is never read as the end of results. One GET, $0.002 (pricing).

---

What you will build:

• A score-bounded search that returns only posts above a threshold with min_score
• A media filter that keeps only self-posts or only videos with is_self and is_video
• A sort_type re-sort that orders a filtered page by score, comment count, or recency
• A pagination loop that reads the meta block to gather a target number of matches

---

The Gap in Native Reddit Search

Native Reddit search takes a query and a sort tab (relevance, new, top, comments) and a time window. What it does not take is a numeric filter. There is no min_score, no min_comments, no "self-posts only" on the public endpoint. For years the answer to that gap was Pushshift, and then its successor pullpush, because they indexed Reddit and let you filter the index directly.

The demand shows up plainly whenever developers discuss what the API costs and what it cannot do. This widely-read r/redditdev thread on API calls names the exact gap in passing, noting that with Pushshift gone you can no longer even average the comment scores across a thread:

r/

r/redditdev·u/Meepster23

Lets talk about those API calls

00

Open on Reddit

The same want surfaces as "is there an API equivalent of comment search," where people expect to filter results by user or subreddit and find the native surface will not do it:

r/

r/redditdev·u/Shajirr

Is there an API equivalent of comment search?

00

Open on Reddit

The honest framing is that Reddit's search index does not expose these filters, so any tool that offers them is filtering after the fetch. That is exactly how pullpush works, and it is how the managed endpoint below works. Understanding that one fact explains everything about the response shape.

---

The Filter Parameters

The managed search endpoint takes your normal q, subreddit, sort, and t, then layers a set of advanced filters on top. They fall into three groups: numeric bounds, boolean flags, and a re-sort.

• Numeric bounds: min_score, max_score, min_comments, max_comments. Each takes a number and bounds the post's score (upvotes) or comment count. A non-numeric value returns a 400.
• Boolean flags: is_video, is_self, over_18, locked, stickied, spoiler, contest_mode. Each takes true or false. is_self=true keeps only text self-posts; is_video=true keeps only hosted video posts; over_18 includes or excludes NSFW.
• Re-sort: sort_type takes score, num_comments, or created and re-orders the filtered page by that field, descending. This is a different axis from Reddit's own sort tab, which is why both can be set at once.

Filters combine. A single call can ask for text self-posts, above 500 upvotes, with at least 50 comments, sorted by comment count:

import os
import requests

API_KEY = os.environ["REDDITAPI_KEY"]
BASE = "https://api.redditapis.com"

resp = requests.get(
    f"{BASE}/api/reddit/search",
    params={
        "q": "postgres vs mysql",
        "min_score": 500,
        "min_comments": 50,
        "is_self": "true",
        "sort_type": "num_comments",
        "limit": 100,
    },
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=60,
)
resp.raise_for_status()
data = resp.json()

for post in data["posts"]:
    print(f"{post['upvotes']:>6} up | {post['comments']:>4} com | {post['title']}")

Note the post fields: the managed path returns upvotes and comments, not the native score and num_comments, so read those names when you print or store a result. The full post shape (id, title, author, permalink, subreddit, over_18, is_self, created_utc, and more) matches the rest of the read endpoints and is documented in the search tutorial.

---

How the Filters Run

Because Reddit will not filter on these fields, the endpoint fetches a page from Reddit's search, then keeps or drops each post against your filters, then re-sorts what survives. That is the pullpush model applied to live search, and it has one consequence you must design around: a filtered page can return far fewer posts than your limit.

To keep that honest, a filtered response adds a meta block that a plain search does not carry:

import os
import requests

API_KEY = os.environ["REDDITAPI_KEY"]
BASE = "https://api.redditapis.com"

resp = requests.get(
    f"{BASE}/api/reddit/search",
    params={"q": "kubernetes", "min_score": 1000, "limit": 100},
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=60,
)
data = resp.json()

print(data["meta"])
# {'fetched': 100, 'returned': 7, 'filtered_out': 93, 'filters': {'min_score': 1000}}
for post in data["posts"]:
    print(post["upvotes"], post["title"])

The meta block reports fetched (how many Reddit returned for the query), returned (how many survived the filter), filtered_out (the difference), and the filters that were applied. Read meta.returned as the count for this page only. A strict filter like min_score=1000 will often keep single digits out of a hundred, and that is correct behavior, not an empty index. When you pass no filters at all, the endpoint returns the plain { posts, after } shape with no meta, so existing callers are untouched.

---

Paginating a Strict Filter

Because a strict filter thins each page, gathering a target number of matches means paging on the after cursor and accumulating until you have enough. Here is the standard pattern:

import os
import requests

API_KEY = os.environ["REDDITAPI_KEY"]
BASE = "https://api.redditapis.com"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def search_filtered(query, want=25, max_pages=10, **filters):
    collected = []
    after = None
    for _ in range(max_pages):
        params = {"q": query, "limit": 100, **filters}
        if after:
            params["after"] = after
        data = requests.get(f"{BASE}/api/reddit/search", params=params,
                            headers=HEADERS, timeout=60).json()
        collected.extend(data["posts"])
        after = data.get("after")
        if len(collected) >= want or not after:
            break
    return collected[:want]

top = search_filtered("local llm", want=25, min_score=200, is_self="true")
print(f"Collected {len(top)} self-posts above 200 upvotes")

Set max_pages deliberately. Reddit caps any single query at 10 pages of 100 results, so max_pages=10 is the ceiling for one keyword. If a very strict filter still comes up short, loosen the bound or vary the query (scope it to a subreddit, or narrow the t window) rather than paging past the cap. The pagination guide covers the cursor mechanics in full.

---

The Pullpush Gap, Closed

Pushshift shut down in 2023, and its community successor pullpush (pullpush.io) kept the filtered-search model alive: score bounds, comment bounds, and field filters over an index of Reddit data. It is free, and it has no uptime guarantee, which is fine for a research script and a real risk for anything customer-facing. The original model is documented in the Pushshift docs, and the migration options are laid out in the Pushshift alternatives roundup.

The managed filters bring that same score, comment, and media filtering to live Reddit search with a maintained IP pool and honest meta. The reliability angle is not academic. Developers keep reaching for no-auth workarounds precisely because the official surface is awkward, and posts like this one, offering to pull Reddit data without keys, get thousands of bookmarks:

Tom Dörr

@tom_doerr

Scrapes Reddit data without API keys https://t.co/JeyRHIaa9P https://t.co/ntPLzeNHVs

The trade is the usual one. Native search is free but has no filters. Pullpush is free, has filters, and has no SLA. A managed path has the filters and a reliability guarantee, priced per call at $0.002 per GET (pricing). Pick on whether reliability or zero cost matters more for your job.

---

What Developers Build on Filtered Search

Score and comment filters are rarely the goal on their own; they are how you raise the signal of a larger pipeline. Three patterns cover most of it, and each leans on a specific filter.

• RAG ingestion. Grounding an LLM answer wants the highest-signal threads, so min_score and min_comments cut the long tail before you spend embeddings on it. Pair with is_self=true when you want discussion text rather than link posts.
• Trend and brand monitoring. Watching for meaningful mentions rather than every mention, min_score filters out the posts nobody engaged with, so an alert fires on a thread that actually gained traction. The keyword monitor walkthrough builds exactly this.
• Dataset building. Assembling a labeled set of, say, video posts or NSFW-flagged content, is_video and over_18 turn a broad query into a clean slice without a second filtering pass in your own code.

The same endpoint serves all three; the filters are what specialize it. If you are wiring search into an agent, the Reddit API for AI agents guide covers the surrounding read calls you will pair with it.

---

Verdict

Native Reddit search gives you a keyword and a sort tab and nothing else, which is why the pullpush and Pushshift questions never fully died. The advanced filters API adds the missing axis: score and comment bounds, media and state flags, and a numeric re-sort, all over one authenticated GET, applied to the page the same way pullpush filters its index. The meta block keeps it honest so a thinned page is never mistaken for an empty one. Native search is free with no filters, pullpush is free with filters and no SLA, and a managed endpoint like https://api.redditapis.com/api/reddit/search gives you the filters plus a reliability guarantee for $0.002 per call. Start free, measure how strict your filters really are, and upgrade when a missing filter becomes a missing feature. Grab a key and filter a query.