How to Get Reddit Comments via the API: Fetch the Full Comment Tree (2026)

The Reddit comments API returns the discussion under a post as a nested tree of comment objects. You fetch it by the post's permalink, and the response is a list of nodes where each node is either a t1 comment (with its text, author, score, and nested replies) or a more placeholder that stands in for comments Reddit did not send in the first call. Getting every comment means walking that tree and expanding the more nodes. This tutorial hands you copy-paste Python for all of it: the fetch, the recursive walk, the more expansion, and the flatten.

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 .json endpoint, the PRAW library, and a managed REST option side by side so you can pick what fits your job.

---

TL;DR: Fetch a post's comments by permalink with one authenticated GET. The response is a tree of t1 comment nodes plus more placeholders. One call returns only the top of the tree: on four 649-to-775-comment threads pulled live on 2026-07-12, a single call returned about 100 comments and left 564 to 701 behind 50 to 70 more nodes, roughly 13 to 15 percent coverage. To get the whole thread, recurse into each comment's replies and expand the more nodes with Reddit's /api/morechildren (or PRAW's replace_more(limit=None)). A managed endpoint like https://api.redditapis.com/api/reddit/comments returns the same tree through a clean IP pool and one bearer token for $0.002 per call (pricing).

---

What you will build:

• A working comment fetch by permalink against both .json and /api/reddit/comments
• A recursive walker that visits every t1 comment in the returned tree
• An expander that turns more placeholders into real comments
• A flattener that produces one clean row per comment for analysis or a RAG index

---

What the Reddit Comments API Returns

The Reddit comments API returns a post's discussion as a nested listing: a comments array where each element is a node with a kind and a data object. A kind of t1 is a real comment carrying its body, author, score, depth, and its own nested replies. A kind of more is a placeholder that Reddit inserts wherever it decided not to send the full set of replies, standing in for comments you have to request separately. Understanding that two-node-type shape is the whole game, because every difficulty with Reddit comments traces back to those more placeholders.

The numbers above are first-party, pulled live from the API on 2026-07-12, and they set up the single most important fact in this guide: on a large thread, one call is not the whole thread. The response also includes a top-level after cursor and the post object itself, so a single request gives you the submission plus the first slice of its comments. Developers in r/redditdev ask the exact question this shape creates, over and over: how do I get every comment, not just the ones the first call returned. This thread is the canonical version of that question and the number-one organic result for the query.

r/redditdev·u/PrincessYukon

Getting *all* the comments in a post

00

Open on Reddit

That question has a clean answer, and the rest of this tutorial is that answer in code. First the single fetch, then the walk, then the part everyone skips: expanding more.

---

Fetch a Post's Comments by Permalink

You fetch comments with a single authenticated GET keyed on the post's permalink. The permalink is the /r/<sub>/comments/<id>/<slug>/ path that rides along on every post object you already have from a search or listing call, so you rarely have to construct it by hand. Here is the managed REST path, live-tested against the production endpoint while writing this tutorial:

import os
import requests

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

permalink = "/r/redditdev/comments/12f885c/getting_all_the_comments_in_a_post/"

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

post = data["post"]
comments = data["comments"]
print(f"{post['title']}")
print(f"top-level nodes returned: {len(comments)}")

The response has three top-level keys: post (the submission), comments (the tree of nodes), and after (a cursor). That is the entire contract. The native path returns the same structure with a different envelope: append .json to any Reddit comment URL and you get back a two-element array whose second element is the comment Listing.

The native equivalent is worth seeing because it is what most older tutorials show and it explains the nesting you will handle in a moment. You request https://www.reddit.com/<permalink>.json with the requests library and a descriptive User-Agent, then read data[1]["data"]["children"]. The no-PRAW Python tutorial covers the surrounding read and write calls that pair with this one, and the authentication guide explains when you need OAuth versus the public .json route.

---

The Comment Object: Fields You Actually Use

A t1 comment node holds dozens of fields, but a handful do all the work. The ones you reach for on nearly every job are body (the markdown text), author (the username), score (net votes, with ups and downs broken out separately), depth (0 for a top-level comment, incrementing per reply level), parent_id (the thing this comment replies to), and created_utc (the epoch timestamp). Everything else is moderation, award, and flair metadata you can usually ignore.

The one field that trips people up is parent_id, because it uses Reddit's type-prefixed fullname scheme. A top-level comment has a parent_id like t3_12f885c, where t3_ marks it as a link (the post itself). A reply has a parent_id like t1_jn24wv6, where t1_ marks it as a comment. That prefix is how you rebuild the hierarchy from a flat list later: match a comment's parent_id against another comment's t1_ plus its id. The replies field is the other structural one. It is either an empty string (this comment has no loaded replies) or a nested Listing object whose data.children array holds the child nodes, which is exactly what makes the tree recursive.

The three node types you will meet map cleanly, and it pays to hold them in your head before writing the walker in the next section:

In practice you branch on kind on every node you touch: process a t1, expand or skip a more, and treat a Listing as a container you recurse into. That three-way branch is the entire control flow of every comment walker in this guide, and the field names above are stable across the native path and a managed proxy alike. The complete field and endpoint contract lives in the API documentation.

---

Walking the Nested Comment Tree

To visit every comment the API returned, you recurse. Each t1 node may carry a replies Listing whose children are more t1 nodes, each of which may carry its own replies, and so on down to whatever depth the thread reaches. A depth-first walker is about ten lines of Python and is the backbone of every comment job you will write. Here is the walker against the managed response shape:

def walk(nodes, depth=0):
    for node in nodes:
        if node["kind"] != "t1":
            continue  # skip 'more' placeholders for now
        c = node["data"]
        yield {
            "id": c["id"],
            "author": c.get("author"),
            "score": c.get("score"),
            "depth": c.get("depth", depth),
            "parent_id": c.get("parent_id"),
            "body": c.get("body", ""),
        }
        replies = c.get("replies")
        if isinstance(replies, dict):
            children = replies.get("data", {}).get("children", [])
            yield from walk(children, depth + 1)

for row in walk(comments):
    indent = "  " * row["depth"]
    print(f"{indent}{row['author']} ({row['score']}): {row['body'][:60]}")

The walker checks kind first. When it sees a t1, it yields the fields you care about and then descends into replies.data.children if that Listing exists. When it sees anything else (a more node), it skips for now. Run this against a small thread and you get essentially the whole discussion; run it against a large one and you get the top of the iceberg, because the more nodes you are skipping are hiding the bulk of the comments. That gap is the subject of the next section, and it is the reason threads like this one keep landing in r/redditdev.

r/redditdev·u/jfasi

How do I use the 'more' entries in the json reply to load more comments?

00

Open on Reddit

Notice the walker never hardcodes a depth limit. Reddit's own nesting can run deep: in the four large threads we sampled, the deepest reply chain reached depth 8. Your recursion should follow the tree as far as it goes rather than stopping at an arbitrary level, or you will silently drop the tail of long back-and-forths.

---

The more Problem: Why One Call Is Not the Whole Thread

Here is the fact that separates a comment fetcher that works in a demo from one that holds up in production: a single comments call does not return the whole thread. Reddit sends the top of the tree and replaces the rest with more placeholder nodes, each carrying a count of how many comments it hides and a children list of their IDs. If you only walk the t1 nodes, you are throwing away most of a busy thread without any error to warn you.

We measured it directly. Pulling four r/technology threads of 649 to 775 comments on 2026-07-12, one call returned about 100 rendered comments each and left between 564 and 701 comments behind 50 to 70 more nodes. That is roughly 13 to 15 percent coverage from a single request. The pattern is consistent: the larger the thread, the smaller the fraction one call gives you. By contrast, a 104-comment r/redditdev thread returned 96 of its comments in one call, about 92 percent, because a small thread fits inside the slice Reddit sends by default.

This is not a bug and it is not a rate limit. It is how Reddit paginates deep trees, documented in the Reddit Data API wiki, and adding limit or depth query parameters does not change it: we tested both against the managed endpoint and the count of returned comments stayed put. The only way past it is to expand the more nodes. Developers hit a sharper edge of this when expansion silently returns nothing, which is its own well-known thread:

r/redditdev·u/iamthatis

What causes "Load more comments" to load nothing/0 new comments?

00

Open on Reddit

If your comment counts never match what you see in the browser, this is almost always why. You walked the t1 nodes and skipped the more ones. The fix is a second step, not a bigger first request.

---

Expanding more and morechildren

Expanding a more node means taking the comment IDs it lists and asking Reddit for those specific comments. On the raw path, that is Reddit's /api/morechildren endpoint: you pass the parent post's fullname and a batch of the children IDs, and it returns those comments so you can splice them back into your tree. On the PRAW path, one method does the whole loop for you. The mechanics are the same underneath; PRAW just hides the bookkeeping.

The PRAW route is the shortest to a complete thread. Its replace_more() method walks the tree and replaces every more placeholder with the real comments, and calling it with limit=None tells it to expand all of them rather than stopping early:

import praw

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

submission = reddit.submission(url="https://www.reddit.com/r/redditdev/comments/12f885c/getting_all_the_comments_in_a_post/")
submission.comments.replace_more(limit=None)   # expand every 'more' node

all_comments = submission.comments.list()       # flat list of every comment
print(f"expanded to {len(all_comments)} comments")

The catch with replace_more(limit=None) is cost: each more expansion is its own request, so a thread with 60 more nodes turns into roughly 60 extra calls, and PRAW paces them against your rate limit. That is exactly why the native /api/morechildren endpoint sees so much confusion in practice, including inconsistent 500s and calls that return less than expected, documented at length in PRAW's comment extraction tutorial and Reddit's official API docs. Whichever route you take, budget for the expansion calls up front. On a managed REST path the comments call returns the same raw tree with the same more nodes, so you apply the identical expansion logic; what the managed pool removes is the OAuth app, the User-Agent tuning, and the datacenter-IP 403s, not the tree structure itself. See the REST versus PRAW breakdown for where each path earns its keep.

---

Flattening the Tree into a Flat List

Most jobs do not want a tree. They want a flat list: one row per comment, ready to score, index, or export. Flattening is the same depth-first walk you already wrote, except you collect every comment into a single list while carrying its depth and parent_id so the hierarchy is reconstructable later. You lose nothing by flattening as long as you keep the parent pointers.

def flatten(nodes, out=None):
    if out is None:
        out = []
    for node in nodes:
        if node["kind"] == "more":
            continue  # expand these first if you need them
        c = node["data"]
        out.append({
            "id": c["id"],
            "parent_id": c.get("parent_id"),
            "depth": c.get("depth", 0),
            "author": c.get("author"),
            "score": c.get("score"),
            "created_utc": c.get("created_utc"),
            "body": c.get("body", ""),
        })
        replies = c.get("replies")
        if isinstance(replies, dict):
            flatten(replies.get("data", {}).get("children", []), out)
    return out

rows = flatten(comments)
print(f"flattened {len(rows)} comments into rows")
# hand `rows` straight to pandas.DataFrame(rows) or json.dump()

The output is a list of dictionaries you can drop into a dataframe with pandas.DataFrame(rows) or write to disk with json.dump(). Because every row keeps its parent_id, you can rebuild the exact reply hierarchy whenever you need it: group by parent_id, or match each row's parent_id against t1_ plus another row's id. The frustration of hand-assembling this structure is a recurring r/redditdev theme, and it is worth acknowledging that yes, if you want the full tree you do have to walk it yourself, whichever path you choose. The no-PRAW tutorial and the search tutorial both lean on this same flatten step when they turn a listing into rows.

---

Native vs PRAW vs a Managed REST Path

Three practical paths get you comments: the native .json endpoint, PRAW, and a managed REST proxy. They return the same underlying data and differ in who handles auth, the IP pool, and the expansion plumbing. There is no single best answer, only the best fit for where your code runs.

A quick read on each. The native .json path is free and needs no library beyond requests, but it caps at 60 requests per minute, gets 403-blocked from cloud IPs, and leaves you to hand-roll the morechildren expansion. PRAW (praw.readthedocs.io) is the most convenient for expansion because replace_more() handles the loop, and it manages OAuth and backoff for you, at the cost of the 100 request-per-minute ceiling and the per-more call fan-out; it is published on PyPI and maintained on GitHub. A managed REST endpoint returns the same tree through a clean pool and one bearer token, which removes the auth setup and the datacenter-IP 403s but still hands you raw more nodes to expand. The demand to get Reddit data without fighting the access layer shows up constantly, and this widely-shared post captures the sentiment:

Tom Dörr

@tom_doerr

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

The honest split: if you are already in PRAW, replace_more(limit=None) is the fastest route to a complete thread. If you are calling from a server where 403s and OAuth upkeep hurt, a managed path removes that class of problem. The data you get out is identical either way. The PRAW versus managed REST comparison walks the tradeoff in more depth.

---

Coverage in Practice: What the Numbers Say

The reason this all matters is that comment coverage is not intuitive, and getting it wrong corrupts whatever you build downstream. A sentiment score computed over 13 percent of a thread is not a sentiment score of the thread; it is a sentiment score of the earliest and highest-voted comments, which skew systematically. So it is worth internalizing the shape of the coverage before you ship a pipeline on top of it.

Across the four large threads we pulled, each single call returned around 100 rendered comments alongside 50 to 70 more placeholders. In node terms, a big chunk of what comes back in one request is not comments at all but pointers to comments you still have to fetch. The practical rule of thumb: if a thread has more than a few hundred comments, plan on expansion, and budget the extra calls. If a thread has under about 200 comments, a single call usually gets you most of it. The scale of this problem at volume is exactly what the scraping throughput and error-rate benchmarks measure, and it is why teams pulling comments at scale care about the rate ceiling covered in the rate-limits reference.

The counterintuitive part is that small threads lie to you. If you build and test your fetcher on a 40-comment thread, it will look complete and correct, because a small thread returns whole. The gap only appears when you point the same code at a 700-comment thread in production, which is precisely when a missing 85 percent of the data does the most damage. Test on a big thread on purpose.

---

Getting Comments Without OAuth

For public posts you can pull comments with no OAuth app at all. Append .json to any Reddit comment URL and request it with a descriptive User-Agent, and Reddit returns the same tree structure at up to 60 requests per minute. This is the zero-setup path, and it is genuinely fine for a notebook, a personal script, or a low-volume job running from your own machine.

The 2026 catch is the IP filter, and it is the single most common reason a correct script fails. Reddit blocks a large share of cloud and datacenter IP ranges, so the exact code that works from your laptop frequently returns 403 from an AWS, GCP, or DigitalOcean box no matter how clean your headers are. That is not a bug in your request; it is Reddit refusing the source IP, and no header fixes it. This short walkthrough covers the same fetch-and-parse flow end to end and is a useful companion to the code above:

The decision is straightforward. From a laptop or a residential connection, the public .json path is the right call: free, no OAuth, and you can paste the walker above and have comments in two minutes. From a server, you either maintain a pool of residential IPs Reddit accepts, or you route through a managed API whose pool is already accepted. The how-to-get-an-API-key guide covers the OAuth-app route if you want to lift the ceiling to 100 requests per minute, though remember that OAuth raises the rate limit without solving the datacenter-IP block.

---

What Developers Build on Comment Data in the Age of AI Search

Comments are rarely the goal on their own; they are the raw material for something else. Four jobs cover most of what teams build on top of a comment fetch, and each one shapes how much of the tree you actually need. Knowing which job you are doing tells you whether the more expansion is optional or mandatory.

Sentiment and opinion analysis needs high coverage, because a partial thread biases the result toward early, high-scoring comments, so this job demands full more expansion. RAG ingestion feeds comment text into an LLM's retrieval index to ground answers in real community discussion, and here completeness matters less than freshness and clean text, so top-of-tree is often enough. Moderation and monitoring tooling watches for specific authors or phrases and usually cares about new comments as they arrive, so a shallow, frequent poll beats a deep one. Thread archiving wants everything, which means full expansion and careful pagination. The pull toward giving an AI agent direct read access to Reddit discussion is a fast-growing pattern, framed plainly here:

Trending GitHub Repositories

@trending_repos

Trending repository of the month 🏆 Agent-Reach Give your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees. Last month: 26,239 ⭐ Total: 47,845 ⭐️ https://t.co/BUp2aLe7ve

Match your expansion effort to the job. If you are grounding an LLM on the gist of a discussion, do not pay for 60 morechildren calls per thread. If you are scoring sentiment or archiving, you have no choice but to expand. The Reddit data licensing context explains why comment data specifically became such a contested resource for AI training, and the find-subreddits guide helps you point these jobs at the right communities.

---

What It Costs at Volume

Comment pulling has two cost axes, and they are different enough that you have to map your real thread sizes before comparing. The native .json path and PRAW are free in dollars but cost engineering time: an IP pool to dodge 403s, OAuth-app upkeep, and the rate-limit backoff you maintain. A managed REST path prices per call instead, at $0.002 per GET (pricing), with no infrastructure to run.

The number that surprises people is the expansion multiplier. A single top-level comments call is one GET, but a large thread with 60 more nodes needs roughly 60 additional expansion requests to reach completeness, so a "read one thread" job is really "read one thread plus expand its sixty more nodes." At low volume this is a rounding error and the free path clearly wins. At production volume, where you are pulling and fully expanding thousands of threads a month, the engineering time to maintain an IP pool and OAuth plumbing costs more than the per-call fee, and a 403 that breaks a customer-facing feature costs more than both. Model your own numbers with the cost calculator and cross-check the per-operation detail on the pricing page and the rate-limits reference before you commit to a path.

---

Verdict

For a notebook or a low-volume script, the native .json path plus the recursive walker above is the right answer: free, no OAuth, and you can have comments in two minutes from your own machine. The moment you need the whole thread, you owe yourself the expansion step, because on a busy thread a single call is only 13 to 15 percent of the comments and the missing 85 percent will quietly corrupt any analysis you run. If you are in PRAW, replace_more(limit=None) is the shortest route to completeness, at the cost of one call per more node. If your code runs on a server where 403s and OAuth upkeep hurt, a managed REST endpoint like https://api.redditapis.com/api/reddit/comments returns the same tree through a clean pool and one bearer token for $0.002 per call, and you apply the identical walk-and-expand logic on top. Start free, test on a big thread on purpose, and upgrade only when the native limits actually bite. Grab a key and run the code.