Reddit Data API in 2026: REST Endpoints, No PRAW, No OAuth

Reddit data access in 2026 splits into two paths. The official path runs through Reddit Inc's Data API on the Standard commercial tier, which starts at $12,000 per year minimum plus per-call fees. That path needs a developer app, an OAuth flow, a client ID and secret pair, and Reddit's commercial approval. Most teams either cannot justify the floor or do not need the contract overhead.

The third-party REST adapter path drops every layer except the data. You sign up, you get a bearer token, you call endpoints directly. No OAuth dance, no developer app, no annual contract. This guide covers the endpoint surface, the pricing, the migration shape from PRAW, and the production patterns that ship in 2026.

The 3 Read Endpoints That Cover Most Workloads

Three GET endpoints handle the vast majority of read workflows:

Endpoint	Use Case	Cost
GET /api/reddit/posts	Subreddit feed (new, hot, top, rising, controversial, best)	$0.002
GET /api/reddit/search	Keyword search across Reddit or scoped to a subreddit	$0.002
GET /api/reddit/sub/:name/top	Top posts by timeframe (day, week, month, year, all)	$0.002

Base URL is https://api.redditapis.com. Auth is a bearer token in the Authorization header. Every response includes a posts array and an after cursor for pagination. Response shape is documented at docs.redditapis.com and stable across versions.

Setup: Get an API Key

Sign up at /signup for an API key and $0.10 in free credit. That covers 50 GET calls before any payment is required:

import os
import requests

API_KEY = os.environ["REDDITAPIS_KEY"]
BASE_URL = "https://api.redditapis.com"

def reddit_get(path: str, params: dict | None = None) -> dict:
    """Generic GET wrapper. Returns the parsed JSON response."""
    response = requests.get(
        f"{BASE_URL}{path}",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params=params or {},
        timeout=30,
    )
    response.raise_for_status()
    return response.json()

That wrapper is the entire setup. No developer app registration, no OAuth callback URL, no praw.ini config. The bearer token is generated when you sign up.

Endpoint 1: Subreddit Feed

The /api/reddit/posts endpoint pulls the post feed for any subreddit:

• subreddit (required): name without the r/ prefix
• sort (optional): new, hot, top, rising, controversial, best (defaults to new)
• t (optional, only for top and controversial): hour, day, week, month, year, all
• limit (optional): 1-100, defaults to 25
• after (optional): pagination cursor in format t3_xxx

def get_subreddit_feed(subreddit: str, sort: str = "new", limit: int = 25) -> list[dict]:
    """Pull the latest posts from a subreddit."""
    data = reddit_get("/api/reddit/posts", {
        "subreddit": subreddit,
        "sort": sort,
        "limit": limit,
    })
    return data["posts"]

# Pull the 50 newest posts from r/ChatGPT
posts = get_subreddit_feed("ChatGPT", sort="new", limit=50)
for p in posts[:5]:
    print(f"{p['upvotes']} | {p['title'][:80]}")

The response shape includes every field you would use for downstream processing: id, title, author, permalink, url, link_url, text, subreddit, upvotes, comments, upvote_ratio, is_self, is_crosspost, crosspost_origin, created_utc, created (ISO-8601), plus flag fields like over_18, stickied, locked, spoiler. The author_info object carries premium status and flair if you need it.

Endpoint 2: Search

The /api/reddit/search endpoint runs Reddit-wide or subreddit-scoped keyword search:

• q (required): the search query
• subreddit (optional): limit results to a specific subreddit
• sort (optional): relevance, new, hot, top, comments
• t (optional): hour, day, week, month, year, all
• nsfw (optional, boolean): include NSFW content
• limit (optional): 1-100
• after (optional): pagination cursor

def search_reddit(query: str, subreddit: str | None = None, sort: str = "new", limit: int = 25) -> list[dict]:
    """Search Reddit for a query, optionally scoped to a subreddit."""
    params = {"q": query, "sort": sort, "limit": limit}
    if subreddit:
        params["subreddit"] = subreddit
    data = reddit_get("/api/reddit/search", params)
    return data["posts"]

# Find all mentions of "GPT-5" in the last week
mentions = search_reddit("GPT-5", sort="new", limit=100)
for m in mentions[:10]:
    print(f"r/{m['subreddit']} | {m['upvotes']} ups | {m['title'][:80]}")

This is the workhorse endpoint for brand monitoring, competitor watch, and topic-level trend tracking. Operators discussed the 2023 transition extensively on r/redditdev's API pricing thread and the Pushshift access removal, both worth reading if you have legacy code that relied on the old free tier.

Endpoint 3: Top Posts by Timeframe

The /api/reddit/sub/:name/top endpoint pulls top posts ranked by score within a timeframe. Subreddit name is a path parameter, not a query parameter:

def get_top_posts(subreddit: str, timeframe: str = "week", limit: int = 25) -> list[dict]:
    """Pull top posts from a subreddit by timeframe."""
    data = reddit_get(f"/api/reddit/sub/{subreddit}/top", {
        "t": timeframe,
        "limit": limit,
    })
    return data["posts"]

# Top 25 posts in r/MachineLearning this month
top = get_top_posts("MachineLearning", timeframe="month", limit=25)
for t in top:
    print(f"{t['upvotes']} ups | {t['comments']} comments | {t['title'][:80]}")

For research workflows that need a stable corpus (paper analysis, sentiment baselines, longitudinal studies), t=all returns the all-time top posts for a subreddit. For trend detection, t=day or t=hour works better.

Pagination

Every response includes an after cursor. To paginate, pass it as the after query parameter on the next call:

def paginate_subreddit(subreddit: str, max_posts: int = 500) -> list[dict]:
    """Paginate through a subreddit feed up to max_posts."""
    all_posts = []
    after = None
    while len(all_posts) < max_posts:
        params = {"subreddit": subreddit, "sort": "new", "limit": 100}
        if after:
            params["after"] = after
        data = reddit_get("/api/reddit/posts", params)
        all_posts.extend(data["posts"])
        after = data.get("after")
        if not after:
            break
    return all_posts[:max_posts]

posts = paginate_subreddit("python", max_posts=300)
print(f"Fetched {len(posts)} posts")

Cursor-based pagination is stable across calls. New posts arriving between calls do not shift your offset. The cursor format is t3_xxx, the Reddit ID prefix used for posts (t1_ for comments, t2_ for users).

Cost Comparison

The cost question is where the third-party REST path wins for most workloads. Three stacks compared at 10,000 reads per month:

Stack	Setup time	Monthly cost (10K reads)	Maintenance	Total fully loaded
PRAW + OAuth + Reddit Standard	1 day	$1,000+ ($12K/year minimum on Standard)	Low	High (annual contract floor)
Self-hosted browser automation	1 week	$80-250 (proxies + anti-bot service)	High (frontend changes)	$300-800/mo + engineer time
Third-party REST adapter	30 minutes	$20 (10K × $0.002)	None	$20/mo

At 100,000 reads per month the REST adapter is $200. The Standard tier is still gated by its annual minimum. Browser-automation stacks scale linearly with proxy and anti-bot costs.

What the REST Adapter Does Not Cover

Three things the REST path does not solve:

• Logged-in views. Private subreddits, NSFW gates that require an account, and user-specific feeds need an authenticated Reddit session. If you need that, you bring your own Reddit credentials and route them through an authenticated endpoint.
• Real-time streaming. Reddit does not ship a public WebSocket. Polling at 60-second intervals is the practical floor for "real-time" workflows on any path, official or third-party.
• Frontend-only elements. Page elements that live only in the Reddit web UI (modal state, JS-injected content, render-time-only data) need a headless browser regardless of which API you use.

For most data workloads, none of these limits matter. They become relevant only at specific edges.

Migration from PRAW

If you have existing code calling PRAW, the migration is a base-URL swap and a response-shape adjustment:

# OLD (PRAW + OAuth + Reddit developer app)
import praw
reddit = praw.Reddit(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
    user_agent="my-app/1.0",
)
for post in reddit.subreddit("python").new(limit=25):
    print(post.title, post.score)

# NEW (third-party REST adapter, bearer token, pay-per-call)
import requests
r = requests.get(
    "https://api.redditapis.com/api/reddit/posts",
    headers={"Authorization": "Bearer YOUR_KEY"},
    params={"subreddit": "python", "sort": "new", "limit": 25},
)
for post in r.json()["posts"]:
    print(post["title"], post["upvotes"])

Field-name map (PRAW attribute → REST JSON field):

• submission.title → post["title"]
• submission.score → post["upvotes"]
• submission.permalink → post["permalink"] (unchanged)
• submission.num_comments → post["comments"]
• submission.created_utc → post["created_utc"]
• submission.author → post["author"]

PRAW's docs reference the full attribute surface if you want to map a less-common attribute. Most migrations finish in under an hour for code that was already using PRAW's submission surface.

When the Math Does Not Work

Pick a different path when:

• You are below 100 reads per month and your project is non-commercial. Reddit's heavily-throttled free tier might cover hobby work, per the Reddit Data API terms.
• You need an official compliance posture. The Standard tier provides a contractual relationship with Reddit Inc, which some regulated buyers require.
• Your workload is frontend-only data extraction (UI-specific rendering). A headless browser is the right tool regardless of API choice.

For everything else (brand monitoring, market research, AI agent data sources, analytics pipelines), the third-party REST path is the cleanest one.

The Operator Take

The Reddit Data API choice in 2026 reduces to three questions:

• Volume. Below 100K reads per month, third-party at $0.002 per call beats the Standard tier on absolute cost.
• Compliance posture. If you need a contractual relationship with Reddit Inc, only the Standard tier provides that. (redditapis.com is not affiliated with Reddit Inc and operates independently as a third-party API provider.)
• Engineering preference. The third-party REST path ships in 30 minutes. The Standard tier path takes 2-4 weeks (OAuth app, commercial approval, contract review).

For deeper background, see the Reddit API rate limits post (covers the 429 patterns), the complete no-PRAW tutorial (general endpoint walkthrough), or the Reddit DM REST guide (write-endpoint specifics).

Sign up at /signup for $0.10 in free credit and the code above runs against real Reddit data in the first 60 seconds. The full API surface for writes, votes, DMs, and account-level operations is documented at docs.redditapis.com.