Reddit User API: Fetch Profile, Karma, and History

The Reddit user API is how you pull public data about a single redditor from code: their profile and karma, the comments they have written, and the posts they have submitted. You hand an endpoint a username and get back structured JSON with the account's karma totals, its age and flags, and paginated lists of that person's comment and submission history. This is the toolkit you reach for whenever you need to vet an account, summarize what someone talks about, or gather a redditor's activity for analysis. This guide shows the whole path with real request and response data and copy-paste Python.

Not affiliated with Reddit Inc. redditapis.com is an independent third-party REST proxy for Reddit's API. This tutorial is vendor-neutral: it shows the native /user/{name}/about.json path and a managed REST option side by side so you can pick what fits your job.

---

TL;DR: A redditor's public data lives across three listings, so reading a full profile is three calls: GET https://api.redditapis.com/api/reddit/user/spez for the profile and karma, GET /api/reddit/user/spez/comments for comment history, and GET /api/reddit/user/spez/submitted for post history, each with one Authorization: Bearer header. The profile call returns karma fields directly (spez shows total_karma: 940312, retrieved 2026-08-02). The two history calls return up to 100 items plus an after cursor you pass back to page through the rest. The native equivalents are /user/{name}/about.json, /comments.json, and /submitted.json, free but rate-limited and 403-blocked from many cloud IPs. A managed endpoint returns the same data through a clean pool for $0.002 per call (pricing).

---

What you will build: a small Python client that takes a username, fetches the profile and karma, reads the comment and submission history, pages through more than one screen of results, and handles suspended or empty accounts without crashing. Every response block below is real data pulled on 2026-08-02.

The four user endpoints

There is no single "get user" call on Reddit. A redditor's public data is split across four endpoints, and knowing which one holds what saves you a lot of guessing. The profile endpoint holds the karma and account flags. The comments endpoint holds the comment history. The submitted endpoint holds the post history. The user-search endpoint resolves a name to an account when you do not already have the exact handle.

Here is how the managed REST paths map to Reddit's native JSON paths.

Each managed path takes a single Authorization: Bearer header and returns clean JSON. Each native path takes an OAuth token (or works unauthenticated at a low rate from a residential IP) and returns Reddit's raw listing envelope. The rest of this guide walks all four, starting with the profile.

Fetch a profile and karma

The profile endpoint is the one most people mean by "the user API." It returns the account's karma, its creation date, and a set of boolean flags (gold, mod, employee, verified). One call, one object.

import requests

API = "https://api.redditapis.com/api/reddit"
KEY = "YOUR_API_KEY"  # from https://www.redditapis.com/signup
HEADERS = {"Authorization": f"Bearer {KEY}"}

def get_profile(username: str) -> dict:
    r = requests.get(f"{API}/user/{username}", headers=HEADERS, timeout=15)
    r.raise_for_status()
    return r.json()

if __name__ == "__main__":
    print(get_profile("spez"))

Reddit's co-founder and CEO, spez, is a good public account to test against because the data is stable and well known. Here is the real response, retrieved 2026-08-02:

{
  "name": "spez",
  "id": "1w72",
  "fullname": "t2_1w72",
  "created_utc": 1118030400,
  "created": "2005-06-06T04:00:00.000Z",
  "link_karma": 184022,
  "comment_karma": 756290,
  "awardee_karma": 0,
  "awarder_karma": 0,
  "total_karma": 940312,
  "is_gold": true,
  "is_mod": true,
  "is_employee": true,
  "verified": true,
  "has_verified_email": true,
  "accept_followers": true,
  "subreddit": {
    "display_name_prefixed": "u/spez",
    "public_description": "Reddit CEO",
    "subreddit_type": "user",
    "over_18": false
  }
}

The account age is right there in created: an ISO date of 2005-06-06, which the API derives from the created_utc epoch so you do not have to. That is a 21-year-old account, and account age is one of the strongest trust signals you can read about a redditor. The is_employee flag being true tells you this is a real Reddit staff account, and the nested subreddit.public_description of "Reddit CEO" is the profile blurb.

What the karma fields mean

The profile response splits karma into four numbers, and mixing them up is the most common mistake when scoring an account. link_karma is earned from posts (links and images). comment_karma is earned from comments. awardee_karma is from awards received, and awarder_karma is from awards given. total_karma is the sum Reddit reports, which is the number to use for a single headline score.

For spez, the split is lopsided in a telling way: 184,022 link karma against 756,290 comment karma. That is a person who earns far more from talking than from posting, which fits a CEO who answers questions in AMAs. Reddit's own karma help page defines each type, and the API returns all of them so you can weight them however your use case needs.

Two accounts with the same total karma can be completely different. A power poster and a prolific commenter both showing a million total karma behave nothing alike, and the link-versus-comment split is what tells them apart before you read a single post. Awardee and awarder karma are usually small or zero (both are zero for spez), but on accounts that trade heavily in awards they carry real signal, which is why the API returns all four rather than a single rolled-up number.

The profile flags and what they certify

Past karma, the profile object carries a set of boolean flags, and each one answers a specific trust question. is_employee is true only for real Reddit staff accounts, so it is the cleanest way to tell an official account from a lookalike. is_mod tells you the account moderates at least one community. is_gold reflects a premium subscription. verified and has_verified_email are account-hygiene signals: a verified email is a low bar, but its absence on an otherwise active account is worth noting. accept_followers tells you whether the account can be followed at all.

The nested subreddit object is the account's own profile page (every redditor has a u_username profile subreddit). Its public_description is the profile blurb, subreddit_type is user for a profile, and over_18 flags a not-safe-for-work profile. For spez that blurb reads "Reddit CEO," which is the one-line self-description the API hands you without a second call. Reading the flags plus the blurb from a single profile response is often enough to classify an account before you touch its history at all.

Read a user's comment history

The comments endpoint returns a redditor's recent comments, newest first by default, with the score, the subreddit, the parent link title, and a timestamp for each one. It is the fastest way to understand what a person actually talks about.

def get_comments(username: str, sort: str = "new", limit: int = 100) -> dict:
    params = {"sort": sort, "limit": limit}
    r = requests.get(f"{API}/user/{username}/comments",
                     headers=HEADERS, params=params, timeout=15)
    r.raise_for_status()
    return r.json()

top = get_comments("spez", sort="top", limit=5)
for c in top["comments"]:
    print(c["upvotes"], "in r/" + c["subreddit"], "->", c["body"][:60])

Sorting by top surfaces a user's highest-scoring comments, which is a quick way to see their most-received takes. Here is the real top comment for spez, retrieved 2026-08-02, trimmed to the fields that matter:

{
  "comments": [
    {
      "id": "cszv2lg",
      "author": "spez",
      "body": "Absolutely. Shadowbanning is for spammers. I created it ten years ago when we were in an arms race with automated spambots...",
      "subreddit": "IAmA",
      "upvotes": 5499,
      "link_title": "I am Steve Huffman, the new CEO of reddit. AMA.",
      "url": "https://reddit.com/r/IAmA/comments/3cxedn/i_am_steve_huffman_the_new_ceo_of_reddit_ama/cszv2lg/",
      "created": "2015-07-11T17:51:48.000Z"
    }
  ],
  "after": "t1_cszv6yi"
}

Each comment carries its own subreddit, so a single pass over a user's comment history tells you which communities they are active in, weighted by how much they get upvoted there. The after value at the end (t1_cszv6yi) is the cursor for the next page, which the pagination section uses. If you need the surrounding thread rather than the flat comment, the Reddit comments API guide covers walking a comment tree by permalink.

The sort parameter accepts new, top, hot, and controversial, so you can pull the most recent activity or the most-received, depending on whether you are monitoring or profiling.

Turn a comment history into a subreddit map

A user's comment history is more useful aggregated than read line by line. Because every comment carries its own subreddit field, one pass over a page of comments tells you which communities a person actually lives in and how much they get received there. That map is often the single most useful thing you can learn about an account.

from collections import Counter

def subreddit_map(username: str, pages: int = 2) -> list:
    comments, after = [], None
    for _ in range(pages):
        params = {"sort": "new", "limit": 100, **({"after": after} if after else {})}
        d = requests.get(f"{API}/user/{username}/comments",
                         headers=HEADERS, params=params, timeout=15).json()
        comments.extend(d["comments"]); after = d.get("after")
        if not after: break
    # count comments per subreddit and sum the score earned in each
    by_sub = Counter(c["subreddit"] for c in comments)
    return by_sub.most_common(10)

The result is a ranked list like [("IAmA", 41), ("announcements", 12), ...]: the communities the account comments in most, in order. Weight it by score instead of count and you get where the account is best received rather than merely most active. This is the core of any "what does this person care about" feature, and it comes out of the comments endpoint alone, no extra calls.

Pull a user's submitted posts

The submitted endpoint is the sibling of the comments endpoint: same shape of call, but it returns the user's posts instead of their comments. Each post carries its title, score, comment count, subreddit, and permalink.

def get_submitted(username: str, sort: str = "new", limit: int = 100) -> dict:
    params = {"sort": sort, "limit": limit}
    r = requests.get(f"{API}/user/{username}/submitted",
                     headers=HEADERS, params=params, timeout=15)
    r.raise_for_status()
    return r.json()

A profile with a stable, well-known post history makes a clearer example here. GallowBoob is one of Reddit's most recognizable power posters, and the top sort over all time returns his highest-scoring submissions. Here is the real top post, retrieved 2026-08-02:

{
  "posts": [
    {
      "id": "gh5c5i",
      "title": "This man jogged 2 miles through his neighborhood carrying a TV in his hands...",
      "author": "GallowBoob",
      "subreddit": "nextfuckinglevel",
      "upvotes": 271299,
      "comments": 10329,
      "permalink": "/r/nextfuckinglevel/comments/gh5c5i/this_man_jogged_2_miles_through_his_neighborhood/",
      "upvote_ratio": 0.95,
      "created": "2020-05-10T17:13:40.000Z"
    }
  ],
  "after": "t3_5pqxdk"
}

Set that against the profile call for the same account, which returns link_karma: 35727323 and total_karma: 36838161 (retrieved 2026-08-02). More than 35 million of that user's karma is link karma, exactly what you would expect from someone whose top post pulled 271,299 upvotes. The profile number and the post history tell one coherent story, which is the whole point of reading both.

spez, by contrast, returns his most recent submission as a self post titled "21 years of Reddit" with 856 upvotes and 286 comments (retrieved 2026-08-02), a reminder that the same endpoint serves a staff account posting once a quarter and a power user posting daily.

The one place developers trip on this endpoint is confusing the comments path with the submitted path. A long-standing r/redditdev question captures it exactly:

r/

r/redditdev·u/Doophie

Get posts of a user with reddit API

00

Open on Reddit

The asker had comments working but could not load a user's posts, because they were hitting the /comments path when they wanted /submitted. The two are separate listings with the same call shape: /comments returns comment objects (with a body), /submitted returns post objects (with a title). If you get comment-shaped data when you expected posts, you are on the wrong path, not looking at a broken response.

Find a user by name

Everything so far assumes you already know the exact username. When you only have a partial name or you are discovering accounts, the user-search endpoint resolves a query to real accounts before you fetch anything.

def search_users(query: str, limit: int = 10) -> dict:
    params = {"q": query, "limit": limit}
    r = requests.get(f"{API}/search/users",
                     headers=HEADERS, params=params, timeout=15)
    r.raise_for_status()
    return r.json()

Each result carries the username, karma, and account age, which is enough to pick the right account out of several similar handles before you spend calls on the full profile and history. Pass nsfw=true to include over-18 accounts, which are excluded by default. This is also the endpoint to reach for when you are building a name-to-account resolver on top of some other list of display names.

One caution: Reddit usernames are not unique by display, and impersonation accounts pick handles a character off from a well-known one. The account age and karma in the search result are your first disambiguation, and the is_employee or verified flags on the full profile are the confirmation. When you are matching a name from an external source (a CRM row, a mention, a signup), resolve it through search, then confirm the single best match with a profile call before you trust it. For discovering posts and comments by topic rather than by author, the Reddit search API tutorial covers the content-search side, and the TypeScript guide shows the same calls in a typed client.

One profile, three requests

Here is the structural fact that shapes every user-data project: Reddit gives you no combined endpoint. A screen that shows a redditor's karma next to their recent activity is making at least two calls, and a full view (stats, posts, comments) is three. A long-running r/redditdev thread on API cost put it plainly.

r/

r/redditdev·u/Meepster23

Lets talk about those API calls

00

Open on Reddit

That thread counts the requests a normal session spends, and the profile line is the relevant one: viewing a profile is separate calls for the user info, for their posts or comments, and for their trophies. Nothing combines them. On the free native path that was only bandwidth. On any metered path it is real money, so the shape of your data model matters.

The practical takeaway is to fetch only what a given screen needs. A leaderboard that ranks accounts by karma needs only the profile call. A "what does this person talk about" view needs the profile plus comments. Reserve the third call for when you genuinely render post history, and cache aggressively when the same accounts come up again.

Page through a full history

The comments and submitted endpoints return up to 100 items per call and an after cursor. To read a history longer than one page, you pass that cursor back on the next request and repeat until after comes back null.

def all_comments(username: str, max_pages: int = 10) -> list:
    out, after, pages = [], None, 0
    while pages < max_pages:
        params = {"sort": "new", "limit": 100}
        if after:
            params["after"] = after
        r = requests.get(f"{API}/user/{username}/comments",
                         headers=HEADERS, params=params, timeout=15)
        r.raise_for_status()
        data = r.json()
        out.extend(data["comments"])
        after = data.get("after")
        pages += 1
        if not after:          # null cursor means no more pages
            break
    return out

Two limits are worth knowing before you loop. First, Reddit caps a live listing at roughly the most recent 1,000 items, so the oldest posts of a very active account are simply not reachable through this path; if you need a complete historical archive you are in dataset or scraping territory, not live-listing territory. Second, every page is a billable read on a metered path and a hit against your rate budget on any path, so bound the loop with a max_pages and stop early on a null cursor rather than spinning. The pagination guide covers the cursor contract in depth, and the rate limits guide covers pacing the loop.

Handle suspended and empty accounts

Three states look similar and must be handled differently. A suspended or deleted account returns a 404 from the profile endpoint, with no body. A live account whose history is genuinely empty (or hidden) returns a valid 200 with an empty comments or posts array and a null after. And a typo in the username also 404s. The rule is simple: treat a 404 as a missing account and an empty array as a real, successful answer.

def safe_profile(username: str) -> dict | None:
    r = requests.get(f"{API}/user/{username}", headers=HEADERS, timeout=15)
    if r.status_code == 404:
        return None            # suspended, deleted, or does not exist
    r.raise_for_status()
    return r.json()

Getting this wrong is how a data pipeline silently drops real users or crashes on the first private account. An empty array is not a failure, and a 404 is not something to retry. If you are looking at an account that seems to exist but returns nothing, that is a different situation from the shadowban question, which is about visibility rather than a hard 404.

A real use case: vet a redditor before you reach out

The most common non-analytics reason to read user data is qualification. Before you engage an account (a lead, a potential collaborator, a source), the profile and history tell you whether it is a real, active person or a throwaway. Account age, the link-versus-comment split, and which subreddits they are active in are a fast, honest signal, and finding the right people is exactly the pull behind a lot of Reddit-based outreach.

Om Patel

@om_patel5

HOW TO GET PAID USERS FOR YOUR STARTUP IN UNDER 5 MINUTES there are people on Reddit RIGHT NOW asking for exactly what you built. here's how to find them: step 1: pick the subreddits where your customers hang out r/smallbusiness, r/marketing, r/freelance, r/ecommerce, https:/… Show more

The pattern is: search or read the accounts you care about, pull each profile for age and karma, pull a page of comments to see which communities they live in, and score from there. If the workflow ends in a message, the Reddit DM API guide covers the send side, and the channel-comparison piece covers when a DM is even the right move. Qualification is a read-heavy job, which is why per-call cost and rate headroom decide whether it scales.

The signals compound. A three-week-old account with a thousand karma, all of it from one subreddit, reads very differently from a five-year account with a balanced split across a dozen communities, and both facts come out of the same two calls.

Native path versus managed path

You can call all four user endpoints natively. Reddit exposes /user/{name}/about.json, /comments.json, /submitted.json, and the user-search listing directly. From a laptop with a residential IP and a descriptive User-Agent, the unauthenticated .json paths return the same data for free at a low rate. That is the right tool for a quick one-off lookup.

The 2026 friction is the datacenter IP filter. The identical call from an AWS, GCP, or Azure range frequently returns 403 regardless of how correct your headers are, so the native path that works on your machine often fails the moment you deploy it to a server. That is the practical reason teams reach for a managed path once a lookup becomes a scheduled job.

A managed REST path routes through a maintained pool with one bearer key, returns the flattened JSON shown throughout this guide, and prices reads at $0.002 per call (pricing, verified 2026-08-02). The authentication guide covers the native OAuth flow if you go that way, and the Reddit data API overview covers the wider endpoint set. For a video walkthrough of fetching a user profile through an API, this tutorial covers the basic call:

Cost and rate for reading user data

Because vetting is read-heavy, the two numbers that decide whether it scales are per-call cost and rate headroom. Every profile, comments, and submitted call is one read. A managed path prices a read at $0.002 (verified against the pricing page on 2026-08-02), so a full three-call profile view is $0.006, and vetting a thousand accounts at three calls each is roughly $6.00 in reads before any caching.

Caching cuts that hard. The same accounts recur across most qualification workflows, so a cache keyed on username with a sensible refresh window collapses repeat lookups to zero calls. On the rate side, the native path's unauthenticated ceiling is low and datacenter-hostile, while OAuth and managed paths give more headroom; the rate limits guide has the budget math, and the pricing breakdown sets read cost against write cost.

There is one more optimization that matters at scale: fetch the cheapest call that answers your question. A leaderboard sorted by karma never needs the history endpoints, so it is one read per account, not three. A "recent activity" widget needs the profile plus one page of comments, so it is two. Only a full profile view genuinely needs all three. Modeling your screens around what each one actually renders, rather than fetching everything by reflex, is the difference between $6 and $2 to vet a thousand accounts. That is the same discipline the bulk-fetch guide applies to hydrating posts: one deliberate call instead of a loop of small ones.

The whole client, end to end

Putting the pieces together, a minimal user-data client is under 40 lines: a profile call, two history calls, a pager, and a 404 guard. Everything below has been run against the live API.

import requests

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

def profile(name):
    r = requests.get(f"{API}/user/{name}", headers=HEADERS, timeout=15)
    return None if r.status_code == 404 else (r.raise_for_status() or r.json())

def history(name, kind="comments", pages=3):
    out, after = [], None
    key = "comments" if kind == "comments" else "posts"
    for _ in range(pages):
        params = {"sort": "new", "limit": 100, **({"after": after} if after else {})}
        d = requests.get(f"{API}/user/{name}/{kind}", headers=HEADERS,
                         params=params, timeout=15).json()
        out.extend(d[key]); after = d.get("after")
        if not after: break
    return out

def vet(name):
    p = profile(name)
    if p is None:
        return {"user": name, "status": "not_found"}
    return {
        "user": name,
        "age": p["created"][:10],
        "total_karma": p["total_karma"],
        "link_vs_comment": (p["link_karma"], p["comment_karma"]),
        "recent_subs": sorted({c["subreddit"] for c in history(name, "comments", 1)}),
    }

if __name__ == "__main__":
    print(vet("spez"))

That vet function is the useful primitive: hand it a username and it returns account age, total karma, the link-versus-comment split, and the set of subreddits the person recently commented in, or a clean not_found for a suspended account. From there you score, filter, or store however your job needs. For other languages, the Python tutorial and the Node.js guide cover the same calls, and the full API documentation lists every field.

Where to go next

The user endpoints are the read layer for anything that reasons about people rather than posts: leaderboards, moderation tooling, audience analysis, and lead qualification. Start with the profile call, add the history calls only where a screen truly needs them, page deliberately, and cache the accounts that recur. When you are ready to run it as a job rather than a script, get a key at signup and read the full documentation for the complete field list and every query parameter.