Reddit Subreddit Moderators and Wiki API (2026)

The Reddit moderators and wiki endpoints turn two things that normally live only on a subreddit's web pages into structured data: who runs the community, and the rules and policy they publish. You send a GET to /r/<sub>/about/moderators.json for the mod team and /r/<sub>/wiki/<page>.json for a wiki page, and you get JSON back. This guide walks both, native and managed, with copy-paste Python, the exact response fields, and the compliance and mod-research jobs they are actually for.

Not affiliated with Reddit Inc. redditapis.com is an independent third-party REST proxy for Reddit's API. This guide is vendor-neutral: it shows the native about/moderators.json and wiki/<page>.json endpoints, the PRAW library, and a managed REST option side by side so you can pick what fits.

---

TL;DR: A subreddit's moderator team is public JSON at https://www.reddit.com/r/<sub>/about/moderators.json, and each wiki page is public JSON at https://www.reddit.com/r/<sub>/wiki/<page>.json. Moderators come back with a username, mod_permissions, and an added date; a wiki page comes back with content_md, the rendered HTML, and its last revision. Both are free but frequently 403 from cloud IPs or a missing read scope. A managed path returns the same fields through a clean pool for $0.002 per GET (pricing).

---

What you will build:

• A moderator-team pull with permissions and added dates against /api/reddit/sub/{name}/moderators
• A rules pull that reads a subreddit's posting rulebook as structured data
• A wiki-page read that returns markdown, HTML, and revision metadata, including multi-segment pages like config/sidebar
• A small compliance snapshot that stores all three per subreddit and re-checks them on a schedule

---

Two Endpoints, One Read Each

The moderators endpoint and the wiki endpoint answer two different governance questions. The first asks who has authority over a community. The second asks what that community has written down. Both are a single read, and both return data that is otherwise trapped in a rendered web page.

The demand for a programmatic mod list is old and constant. Developers have asked for it in r/redditdev for years, because the website shows the mod team but the path to it in code is easy to miss:

r/

r/redditdev·u/rikosmith

How to get list of moderators of a subreddit using PRAW?

00

Open on Reddit

This guide does what most pages skip: it hands you working Python for both endpoints and names the exact response fields, instead of pointing at the docs and moving on.

---

The Moderators Endpoint

Reddit serves a subreddit's moderator team at https://www.reddit.com/r/<sub>/about/moderators.json. The response is a listing whose data.children array holds one object per moderator. On the managed path the same data comes back as a flat moderators array. Here is the managed call, live-tested against the production endpoint:

import os
import requests

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

resp = requests.get(
    f"{BASE}/api/reddit/sub/python/moderators",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=60,
)
resp.raise_for_status()
data = resp.json()

for mod in data["moderators"]:
    perms = ", ".join(mod["mod_permissions"]) or "none listed"
    print(f"u/{mod['name']:<20} | {perms}")
    if mod["added"]:
        print(f"    added {mod['added']}")

Each moderator object carries name (the username), id, a mod_permissions array, flair_text, and both added_utc (the raw epoch) and added (an ISO timestamp). The mod_permissions array is the useful part for research: it lists what each mod can do, with all meaning full permissions, or a specific set like posts, wiki, flair, and mail. A brand new mod with narrow duties looks very different from a founder with all.

The native equivalent is the same URL without the /api proxy, but it is also where most people first hit a wall. This resolved thread is the canonical one: a correct-looking call to /about/moderators returns 403, and the fix turns out to be the OAuth read scope, not the code:

r/

r/redditdev·u/thereweirdo

[/r/subreddit]/about/moderators showing 403 Forbidden response

00

Open on Reddit

The three causes are worth stating plainly, because they account for nearly every moderators 403 in 2026:

1. Missing read scope. The token authorized without read, so it can identify the user but cannot read subreddit data. Request read when you build the authorize URL.
2. Missing or banned User-Agent. Send a descriptive one like myapp/1.0 (by u/yourusername); a generic library default gets rejected.
3. Filtered IP. A datacenter or cloud IP that Reddit blocks returns 403 no matter how correct the token is. There is no header that fixes a filtered IP.

A managed REST path handles the token and routes through an accepted pool, so the moderators call returns 200 without the scope and IP debugging. For the full picture of scopes and tokens, the authentication and OAuth guide is the companion read.

---

The Rules Endpoint

A subreddit's rules are structured data, separate from the free-form wiki. Reddit configures them in the community settings, and they come back at /api/reddit/sub/<name>/rules as an array plus the site-wide rules. This is the machine-readable rulebook, and it is the first thing a posting-safety or compliance job should read:

import os
import requests

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

resp = requests.get(
    f"{BASE}/api/reddit/sub/python/rules",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=60,
)
rules = resp.json()["rules"]

for r in rules:
    print(f"[{r['applies_to']}] {r['name']}")
    if r["description"]:
        print(f"    {r['description'][:100]}")

Each rule carries name (the short label), description, applies_to (which is posts, comments, or all), an optional violation_reason, a priority, and a created timestamp. The applies_to field is what a bot needs before it submits: a rule that applies to comments should not block a link submission, and vice versa. If your workload is a submission or reply pipeline, read the rules first and gate on applies_to. The subreddit rules comparison covers how this fits alongside the other read endpoints.

---

The Wiki Endpoint

Where rules are structured, the wiki is prose. Moderators write pages by hand for the things that do not fit the rules form: the long posting guide, the community FAQ, a policy page, or the AutoModerator config. Reddit serves each page as JSON at /r/<sub>/wiki/<page>.json, and the managed path mirrors it at /api/reddit/sub/<name>/wiki/<page>:

import os
import requests

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

resp = requests.get(
    f"{BASE}/api/reddit/sub/python/wiki/index",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=60,
)
page = resp.json()

print("may_revise:", page["may_revise"])
print("last revised:", page["revision_date"], "by", page["revised_by"])
print(page["content_md"][:400])

The response is one object with page (echoing what you asked for), content_md (the raw markdown), content_html (the rendered version), may_revise (whether the caller could edit it), and the last revision as revision_id, revision_date, and revised_by. Reading content_md gives you the exact source a moderator wrote, which is what you want for a diff or an archive; content_html is better if you are rendering it back to a page.

The page name can be multi-segment. index is the wiki home, rules is a common long-form rules page, and config/sidebar or config/automoderator reach the configuration pages. Pass the full path after /wiki/:

resp = requests.get(
    f"{BASE}/api/reddit/sub/python/wiki/config/sidebar",
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=60,
)
print(resp.json()["content_md"][:200])

Two responses are worth handling explicitly. A page that does not exist returns 404. A restricted page returns a 403 whose body carries a MAY_NOT_VIEW reason, which this real thread captures exactly when reading config/automoderator on a locked-down subreddit:

r/

r/redditdev·u/Littux

Using bookmarklets to create simple scripts instead of begging for a client id

00

Open on Reddit

So in code, treat 404 as "no such page, move on" and treat a MAY_NOT_VIEW 403 as "this page is mod-only, skip it," rather than retrying either.

---

The Same Reads in PRAW

If you are already in the PRAW ecosystem, the same three reads are available on the model objects. subreddit.moderator() returns the mod team, subreddit.rules returns the rules, and subreddit.wiki[page] returns a wiki page. Per the PRAW Subreddit reference:

import praw

reddit = praw.Reddit(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
    user_agent="mod-audit/1.0 (by u/your_username)",
)

sub = reddit.subreddit("python")

for mod in sub.moderator():
    print(mod.name, list(mod.mod_permissions))

wiki_index = sub.wiki["index"]
print(wiki_index.content_md[:300])

PRAW handles the OAuth flow and rate-limit backoff for you, which is its main advantage. Its constraints are the same as the native endpoint: you provide the OAuth app, the read scope, and an IP Reddit does not filter. The REST vs PRAW comparison goes deeper on that tradeoff.

---

Why Read This as Data: Compliance and Mod Research

Pulling a mod team and a rulebook is rarely the goal on its own. It is the input to a larger job, and three patterns cover most of what teams build on top of it. Each one wants the same three reads on a schedule.

Compliance and brand safety. Before a brand, an agency, or an automated poster touches a community, someone has to confirm the rules allow what they plan to do. Reading /rules and the relevant wiki pages as data lets you gate posting programmatically and keep an auditable record of what a subreddit's rules were on the day you posted. Reddit's own Public Content Policy is explicit that programmatic access carries obligations, and the admin post below spells out the direction of travel: automated access is expected to follow the terms, not route around them.

r/

r/redditdev·u/traceroo

Updating our robots.txt file and Upholding our Public Content Policy

00

Open on Reddit

Mod-team research. Who moderates a community, how many mods it has, how concentrated permissions are, and when the team last changed are all signals for trust-and-safety research, competitive analysis, and academic work. The mod_permissions and added fields make that quantifiable rather than anecdotal.

Data governance for AI pipelines. If Reddit content feeds a model or a product, the rules and wiki are the governance layer around that content. The stakes are not hypothetical: a 2026 paper from ETH Zurich and Anthropic showed that a language model can re-identify anonymous authors from a handful of their Reddit comments, which is exactly why reading a community's own stated rules before ingesting it matters.

Alex Veremeyenko

@alex_verem

Holy shit… Your anonymous internet identity can now be unmasked for $1 😳 Not by the FBI. By anyone with access to Claude or ChatGPT and a few of your Reddit comments. ETH Zurich and Anthropic just dropped a paper called “Large-Scale Online Deanonymization with LLMs” and the ht… Show more

---

A Small Compliance Snapshot

Here is the shape most compliance jobs end up with: one function that reads all three surfaces for a subreddit and returns a single record you can store and diff on the next run.

import os
import requests

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

def snapshot(sub):
    mods = requests.get(f"{BASE}/api/reddit/sub/{sub}/moderators",
                        headers=HEADERS, timeout=60).json()["moderators"]
    rules = requests.get(f"{BASE}/api/reddit/sub/{sub}/rules",
                         headers=HEADERS, timeout=60).json()["rules"]
    try:
        index = requests.get(f"{BASE}/api/reddit/sub/{sub}/wiki/index",
                             headers=HEADERS, timeout=60).json()
        wiki_md = index.get("content_md")
    except requests.HTTPError:
        wiki_md = None
    return {
        "subreddit": sub,
        "mod_count": len(mods),
        "mods": [m["name"] for m in mods],
        "rule_count": len(rules),
        "rules": [r["name"] for r in rules],
        "wiki_index_present": wiki_md is not None,
    }

print(snapshot("python"))

That is three GETs per subreddit, or $0.006 at $0.002 per call. Store the record, run it weekly, and a diff tells you when a mod joined or left, when a rule changed, or when a wiki page was rewritten. Model your own volume with the cost calculator before you scale it across a watchlist.

---

Native, PRAW, or Managed: Choosing a Path

The data is identical across all three paths; what differs is who runs the auth, the IP pool, and the rate limiting. For a one-off audit from your laptop, the native about/moderators.json and wiki/<page>.json endpoints are free and fine. For a job already inside PRAW, subreddit.moderator() and subreddit.wiki[page] are the natural call. For a compliance or research pipeline that runs from a server, on a schedule, across many subreddits, and cannot tolerate an intermittent 403, a managed REST path is the trade most teams make, because a moderators call that silently fails is a hole in the audit rather than a logging nuisance.

Start on the native endpoints, confirm the read scope fixes your 403, and move to a managed path only when the reads become load-bearing. The rate-limits reference and the pricing page have the per-operation detail.

---

Verdict

The moderators, rules, and wiki endpoints exist to turn a subreddit's governance into data. The mod team is public JSON, the rules are structured JSON, and the wiki is JSON-wrapped markdown, and each one is a single read. On the native path they are free but gated behind the read scope, a real User-Agent, and an IP Reddit accepts, which is why the r/redditdev threads about a 403 on /about/moderators never stop. A managed REST endpoint like https://api.redditapis.com/api/reddit/sub/{name}/moderators returns the same three surfaces through a clean pool for $0.002 per call, which is the sensible choice once compliance or research depends on the read landing every time. Grab a key and run the snapshot.