Reddit Subreddit Rules API: Pull Posting Rules as JSON

The subreddit rules API returns a community's posting rules as structured JSON instead of prose you have to read off the sidebar. You send the subreddit name to one endpoint, and the response is an array of rule objects, each carrying the rule's name, its full description, what it applies to (posts, comments, or both), and the reason a moderator cites when removing content under it, plus Reddit's site-wide rules. This is the endpoint you reach for whenever code needs to know a community's rules: a compliance check, an auto-moderation bot, or a pre-submit validator that answers "will this post survive." This guide shows the whole path in 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 /about/rules.json path and a managed REST option side by side so you can pick what fits your job.

---

TL;DR: To pull a subreddit's rules, call GET https://api.redditapis.com/api/reddit/sub/<name>/rules, which returns a rules array and a site_rules array in one authenticated request. Each rule carries name, description, applies_to (posts, comments, or all), violation_reason, and priority. Use it to build pre-submit validation and compliance checks, though it cannot see a subreddit's private AutoModerator config, so treat the check as necessary but not sufficient. The native equivalent is https://www.reddit.com/r/<name>/about/rules.json, free but rate-limited and 403-blocked from many cloud IPs. A managed endpoint returns the same rules through a clean pool and one bearer token for $0.002 per call (pricing).

---

What you will build:

• A single rules call that turns a subreddit name into structured rule objects
• A pre-submit validator that tests a draft against the rules you can evaluate
• A loop that reads and caches rules across many communities
• The native reddit.com/r/<name>/about/rules.json comparison and its 403 and rate-limit pitfalls

---

One Call Returns Every Rule

The rules endpoint takes a subreddit name and returns its full rule set in one response. There is no pagination and no tree to walk: you get a flat rules array plus a separate site_rules array, and that is the entire contract. Here is the call, one authenticated GET keyed on the subreddit name:

import os
import requests

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

def get_rules(name):
    resp = requests.get(
        f"{BASE}/api/reddit/sub/{name}/rules",
        headers=HEADERS,
        timeout=60,
    )
    resp.raise_for_status()
    return resp.json()

data = get_rules("python")
for r in data["rules"]:
    print(f"[{r['applies_to']:>8}] {r['name']}")
    if r["description"]:
        print(f"           {r['description'][:80]}")

The response has two top-level keys: rules (the community's own rules, in display order) and site_rules (Reddit's site-wide rules that apply everywhere). A subreddit that does not exist returns a 404, the same way the about endpoint does, so you can trust that a 200 means the community is real and its rules are current.

One read, the whole rule set

The value of the endpoint is that it hands you rules as data rather than paragraphs. A subreddit's rules live in its sidebar as human prose, and reading them is fine for a person posting once. It falls apart the moment code needs to know the rules, or you need them for fifty communities, or you want to re-check them on a schedule. This is the exact question developers keep asking on Reddit's own forum, wanting the enforced rules of a subreddit rather than a page they have to read:

r/

r/redditdev·u/Mountain_Primary4465

Can i programmatically get posting rules of a subreddit ?

00

Open on Reddit

The rules endpoint answers the first half of that question directly. The second half, the rules enforced by a subreddit's private AutoModerator config, is not exposed by any public endpoint, and that boundary matters enough that it gets its own section below.

---

The Rule Object: Fields You Use

Each element of the rules array is a rule object, and a handful of fields do all the work. The ones you reach for on nearly every job are name (the short rule title, like "No self-promotion"), description (the full explanation the moderators wrote), and applies_to (whether the rule governs posts, comments, or both). Alongside those sit violation_reason (the label a moderator picks when removing content under this rule), priority (its display order in the sidebar), and created_utc with an ISO created timestamp so you can see when a rule was added.

The applies_to field is the one that changes how you use a rule. Reddit models each rule as governing links (posts), comments, or all content, and the endpoint normalizes that into a plain posts, comments, or all string. For a pre-submit check on a link post, you only care about rules where applies_to is posts or all; a comment-only rule is irrelevant to whether your submission survives. Filtering on applies_to first is what keeps a validator from flagging a draft against a rule that does not apply to it.

Here is a compact reader that pulls just the fields a posting tool needs and splits the rules by what they govern:

def rules_for_posts(name):
    data = get_rules(name)
    post_rules = [
        {"name": r["name"], "desc": r["description"], "reason": r["violation_reason"]}
        for r in data["rules"]
        if r["applies_to"] in ("posts", "all")
    ]
    return post_rules, data["site_rules"]

post_rules, site_rules = rules_for_posts("dataengineering")
print(f"{len(post_rules)} rules apply to posts, plus {len(site_rules)} site-wide")

The violation_reason field is worth keeping even when you do not display it, because it is the exact string that shows up on a removed post. If you are building moderation tooling, matching a removal against its violation_reason is how you attribute a takedown to a specific rule. Developers who work with removals learn this vocabulary the hard way, sometimes reverse-engineering the removal-reason plumbing that the rules endpoint exposes cleanly:

r/

r/redditdev·u/BGFlyingToaster

Getting Removal Reason IDs via Oauth API or PRAW

00

Open on Reddit

---

Build a Pre-Submit Validator

The highest-value use of the rules endpoint is checking a draft before you post it. You cannot guarantee a post survives, but you can catch the common, mechanical removals: a missing required flair, a title that breaks a length rule, a body that contains a phrase a rule names. The pattern is: fetch the rules once, then test the draft against the ones you can evaluate in code.

Check a draft before you post it

Here is a validator that runs a draft against the post-facing rules. It is deliberately simple, checking the mechanical constraints that cause most removals, and it returns the rules it could not evaluate so you know what it did not check:

def validate_draft(name, title, body, has_flair):
    post_rules, site_rules = rules_for_posts(name)
    problems = []
    unchecked = []
    for r in post_rules:
        text = f"{r['name']} {r['desc']}".lower()
        if "flair" in text and "required" in text and not has_flair:
            problems.append(f"needs flair: {r['name']}")
        elif "title" in text and ("format" in text or "must" in text):
            unchecked.append(r["name"])  # human-judgment rule
        else:
            unchecked.append(r["name"])
    return {"ok": not problems, "problems": problems, "unchecked": unchecked}

result = validate_draft(
    "learnpython",
    title="How do I read a CSV without pandas?",
    body="I want to avoid the dependency...",
    has_flair=False,
)
print(result)

Be honest about what this catches. A rule like "Posts must have a flair" is mechanical and a validator handles it cleanly. A rule like "Low-effort posts will be removed" is a human judgment no API can score, so the validator lists it under unchecked rather than pretending to evaluate it. The value is in the split: the tool clears the mechanical rules automatically and surfaces the judgment rules for a person to weigh, instead of you re-reading every sidebar by hand for every community.

There is a growing pull toward giving an agent this kind of programmatic read on a community before it acts, because the alternative is an agent posting blind into rules it never checked:

Yarchi

@undefinedKi

Your agent can read X, Reddit, Instagram and Facebook now. One command, free Those platforms are closed to Claude. Anonymous requests get blocked, and the official Twitter API runs about $215 a month for moderate use. Agent Reach routes around it. 61,000 stars, MIT. What it htt… Show more

The rules endpoint is the read half of that loop: it turns "what are the rules here" from a page you skim into a JSON object your code evaluates.

---

The AutoModerator Boundary

Here is the limit you have to design around: the rules endpoint returns the rules a subreddit publishes, not everything that gets a post removed. Many communities enforce additional requirements through AutoModerator, a moderator-configured tool whose rules live in a private config/automoderator wiki page that no public endpoint exposes. A minimum account age, a karma floor, a required title pattern, a domain blocklist: these can all be enforced by automod and none of them appear in the published rules JSON.

Reading the sidebar versus the rules API

The grid shows why the API wins for tooling even with the automod caveat: the published rules become machine-readable, scale across communities in a loop, fit inside a bot, and refresh on a schedule, none of which reading the sidebar by hand can do. What the API cannot do is read the private automod config, which is why a pre-submit check is a strong filter, not a guarantee. The developer question that opened this guide made this exact distinction, asking for the rules enforced by automod and not just the ones in the sidebar wiki, and the honest answer is that the published rules are the ceiling of what any public endpoint returns.

Design for it. Use the rules endpoint to catch the removals you can see coming, and expect a residual rate of removals from automod checks you cannot inspect in advance. For a serious posting tool, the practical move is to pair the rules check with a post-submit verification: submit, then read the post back a short while later to confirm it was not removed, so an automod takedown you could not predict still gets caught. Reddit's own AutoModerator documentation explains what the tool can enforce, which is a useful map of the removals the rules endpoint will not warn you about.

---

Read Rules Across Many Subreddits

There is no bulk-rules endpoint, so reading rules for a list of communities is a loop, one call per subreddit. Because each response is structured JSON, you store the results keyed by subreddit name and re-fetch on a schedule to stay current. Here is the multi-subreddit reader with a simple in-memory cache:

import time

_cache = {}  # name -> (fetched_at, rules_data)
TTL = 60 * 60 * 24  # re-fetch rules once a day

def get_rules_cached(name):
    now = time.time()
    hit = _cache.get(name)
    if hit and now - hit[0] < TTL:
        return hit[1]
    data = get_rules(name)
    _cache[name] = (now, data)
    return data

communities = ["python", "learnpython", "dataengineering", "django"]
for name in communities:
    data = get_rules_cached(name)
    post_rules = [r for r in data["rules"] if r["applies_to"] in ("posts", "all")]
    print(f"r/{name}: {len(post_rules)} post rules")

The cache matters because rules change slowly. Moderators edit rules over weeks and months, not minutes, so re-fetching them on every single submit is wasted spend. Cache per subreddit with a timestamp and refresh daily or weekly, and you keep the rules current without paying to re-read an unchanged rule set on every post. The created_utc on each rule lets you spot a newly added rule between refreshes if you want to alert on rule changes rather than just consume them.

This loop-and-cache shape is what a cross-posting tool, a compliance dashboard, or a multi-community auto-moderation bot is built on. You maintain a set of communities you post into, keep their rules cached and fresh, and run every draft through the validator before it goes out. The find-subreddits guide covers building that community list in the first place, and the rules endpoint is the compliance layer you put on top of it.

---

The Native reddit.com/about/rules Path (and Its Limits)

Reddit exposes rules directly. Append .json to a subreddit's about/rules path and you get the same data unauthenticated: https://www.reddit.com/r/<name>/about/rules.json. It is free, needs no developer app, and is the right tool for a quick check from your own machine. Here is the native call:

import requests

URL_TMPL = "https://www.reddit.com/r/{name}/about/rules.json"
HEADERS = {"User-Agent": "rules-tutorial/1.0 (by u/your_username)"}

def get_rules_native(name):
    resp = requests.get(URL_TMPL.format(name=name), headers=HEADERS, timeout=30)
    resp.raise_for_status()
    return resp.json()

data = get_rules_native("python")
for r in data["rules"]:
    # native fields: short_name, description, kind, violation_reason, priority
    print(f"[{r['kind']:>7}] {r['short_name']}")

The native response carries the same information with raw Reddit field names: each rule has short_name (rather than a normalized name), description, kind (Reddit's raw link / comment / all value that a managed path normalizes to posts / comments / all), violation_reason, and priority, plus the same top-level site_rules array. If you build on the native path, map kind yourself: link means the rule governs posts, comment means comments, and all means both.

Two things limit the native path in production. First, the rate ceiling of 60 requests per minute unauthenticated, which is tight once you are reading rules across many communities in a loop. Second, and more disruptive in 2026, the IP filter: Reddit blocks a large share of cloud and datacenter IP ranges, so the same call that works from your laptop returns 403 from a server no matter how clean your headers are. The quick diagnosis is to run the identical script locally; if it works on your laptop and 403s on the box, the source IP is filtered, not your code. The managed path trades the dollar cost of the call for a clean pool, one bearer header, and normalized field names. For the broader access picture, see the authentication and OAuth guide and the rate-limits reference.

---

What It Costs at Volume

Reading rules has a cost shape that rewards caching, not batching, because there is no bulk endpoint. The native .json path is free in dollars but costs engineering time: an IP pool to dodge 403s, OAuth-app upkeep, and rate-limit backoff. A managed REST path prices per call instead, at $0.002 per GET (pricing), with the first $0.50 of credit free at signup and no card required.

One rules read is one GET, so the cost scales with how often you re-fetch, which is exactly why the cache matters. A posting tool covering 100 communities that refreshes rules daily is 100 GETs a day, roughly $0.20 a month, because rules change slowly enough that a daily refresh is plenty. Re-fetching rules on every submit instead of caching them would multiply that by your posting volume for no benefit, since the rules did not change between posts. Model your real numbers with the cost calculator and cross-check the per-operation detail on the pricing page before you commit to a path.

---

Verdict

For a one-off check of a single community from your own machine, the native reddit.com/r/<name>/about/rules.json path is the right answer: free, no OAuth, and you can paste the code above and have the rules in two minutes. The moment code needs the rules (a pre-submit validator, a compliance check, a multi-community bot) the managed path earns its keep, because it returns the rules as normalized JSON through a clean pool, and you loop and cache it across communities without fighting 403s. The pipeline is small: fetch the rules, filter by applies_to, run your draft through a validator for the mechanical rules, and pair it with a post-submit read to catch the automod removals the rules endpoint cannot see. Start with the free path, measure how many communities you cover and how often rules change, and move to a managed endpoint like https://api.redditapis.com/api/reddit/sub/<name>/rules when the loop and the 403s start to bite. The subreddit about guide covers the metadata that sits beside the rules, the search tutorial covers finding content inside a community, and the authentication guide covers the access layer underneath all of it. Grab a free key and pull the rules.