Reddit Trends Scraper & Top Comments

Reddit Trends Scraper — Posts, Comments and a Free Comment Dataset

Reddit Trends Scraper & Top Comments pulls trending posts from any subreddit, user, keyword search, or Reddit URL, then follows each post into its comment tree and returns author, body, score, depth and parent for every comment it collects. Post and comment rows land in the same dataset, interleaved in reading order, and every response is typed JSON — ready to pass straight into an LLM, index into a vector store, or feed a monitoring pipeline. Point it at r/technology, u/spez, or a keyword like "layoffs" and it turns a browsing session into a structured dataset in one run.

What is Reddit Trends Scraper & Top Comments?

Reddit Trends Scraper & Top Comments is an Apify Actor that queries Reddit's public post listings and comment pages and returns two row types — posts and comments — in one dataset. It queries old.reddit.com rather than Reddit's app, because that surface serves complete HTML for both listings and comment trees without a client-side app shell. No Reddit account, login, cookie or session is used anywhere in the code — every field returned is already visible to an anonymous visitor.

Alongside the standard post fields, every run of this Actor mirrors its comments into a second, uncharged dataset scoped to that run — a comment-only export you get for free alongside the main charged dataset.

• Four ways in — a raw Reddit URL, a subreddit (r/technology), a username (u/spez), or a free-text keyword search, mixed freely in one list
• Server-side post sorting — hot, new, top, rising, controversial
• Nested comment threads — recursively expands reply trees to a configurable depth, with a separate cap on total comment rows per post
• Parent/child interleaving — every row carries type (post/comment) and isChild, and each comment carries parentId so the tree can be rebuilt without a second lookup
• A free comment mirror dataset — comments are also written, uncharged, to a per-run dataset named reddit-comments-<runId>
• Hidden-score honesty — when Reddit hides a score, the field comes back null, never a fake 0

What data can you get with Reddit Trends Scraper & Top Comments?

Every run returns two row types in the same dataset — posts and their comments — distinguished by the type field.

Result Type	Extracted Fields	Primary Use Case
Post rows (type: "post")	type, isChild, parentId, title, postUrl, upvotes, comments, subreddit, subredditUrl, subredditType, author, authorProfile, postTime, postId, createdAt, scrapedAt	Trend spotting, content-performance tracking, subreddit monitoring
Comment rows (type: "comment")	type, isChild, commentId, postId, parentId, depth, author, authorProfile, body, upvotes, commentUrl, createdAt, isSubmitter, scrapedAt	Sentiment and opinion mining, surfacing top comments, thread reconstruction

Interleaved rows and a free comment-only dataset

This is the part other Reddit scrapers on Apify don't document: every comment row this Actor writes to the main dataset is also written a second time, unmodified, to a per-run dataset named reddit-comments-<runId> — and that second write carries no charged_event_name, so it costs nothing beyond the charge already applied to the main-dataset row. You get a comment-only export for free, without filtering the combined dataset yourself. The main dataset stays a single ordered feed: each post row is immediately followed by its own comment rows, each one carrying parentId (the post's ID for top-level comments, the parent comment's ID for replies) and depth (0 for top-level, incrementing with each nesting level), so the full reply tree is reconstructable from parentId alone:

{
  "type": "comment",
  "isChild": true,
  "commentId": "lm9k2p1",
  "postId": "1oc7g4x",
  "parentId": "1oc7g4x",
  "depth": 0,
  "author": "data_nerd_42",
  "upvotes": 214,
  "isSubmitter": false
}

The mirror dataset's name is deterministic — reddit-comments- followed by the run's own ID — so you can fetch it programmatically the moment a run finishes, without parsing the run's log or output to discover it: client.dataset("reddit-comments-<runId>").iterate_items() in the Apify Python client, or the equivalent named-dataset lookup in any other Apify SDK.

Nested comment threads

maxCommentDepth controls how many reply levels are followed — 0 returns only top-level comments, 3 (the default) follows three levels of replies beneath them. expandMoreComments asks Reddit to inline more of the collapsed "load more" branches before that depth cut-off is applied, so threads that Reddit folds by default are still recovered up to your depth and per-post caps. commentSort controls the order comments are collected in — confidence (Reddit's own "Best"), top, new, controversial, old, or qa — and isSubmitter flags a reply written by the post's own author, useful for isolating OP follow-ups in a thread.

How does Reddit Trends Scraper differ from the official Reddit API?

Reddit publishes an official Data API for developers, gated behind OAuth app registration — if you already have that access and want to build directly against Reddit's own endpoints and terms, use it. Reddit Trends Scraper & Top Comments exists for the case where you want a structured Reddit dataset without setting up an OAuth app first. Current scopes, tiers and rate limits are Reddit's to define and change, so check Reddit's own published API documentation before committing to either path — they are not reproduced here.

Feature	Official Reddit API	Reddit Trends Scraper & Top Comments
Setup required	Developer app registration + OAuth flow	Paste a URL, subreddit, user, or keyword and start
Credentials needed	Reddit API client ID/secret	None — only your Apify account
Post + comment interleaving	Not provided — caller composes it from separate calls	Built in — one dataset, type/isChild/parentId on every row
Comment-only export	Not applicable	Free, uncharged per-run mirror dataset
Output shape	Reddit's own API schema, versioned by Reddit	One normalized JSON row per post or comment, same shape every run
Scope and limits	Defined by Reddit's current API terms — check their docs	Bounded by the maxPosts, maxCommentsPerPost and maxCommentDepth inputs

Use the official API when you have developer access and need to build a production integration under Reddit's own contractual terms. Use Reddit Trends Scraper & Top Comments for ad-hoc research, trend snapshots, and comment pulls you want running in minutes without an OAuth app.

How to scrape Reddit with Reddit Trends Scraper & Top Comments?

1. Open Reddit Trends Scraper & Top Comments on the Apify Store and click Try for free
2. Add one or more entries to Reddit URLs, Subreddits, Users, or Keywords (startUrls) — a full URL, r/technology, u/spez, or a keyword phrase
3. Set Post Sort Order (sortBy) and Maximum Posts (maxPosts), then configure the comment controls — includeComments, maxCommentsPerPost, commentSort, maxCommentDepth, expandMoreComments
4. Click Start
5. Download the dataset as JSON, CSV, Excel or the other formats Apify supports, or read the free comment mirror dataset (reddit-comments-<runId>) separately through the Apify API

{
  "startUrls": ["https://www.reddit.com/r/technology/", "r/programming", "u/spez"],
  "sortBy": "top",
  "maxPosts": 15,
  "includeComments": true,
  "maxCommentsPerPost": 25,
  "commentSort": "top",
  "maxCommentDepth": 2
}

How to run multiple sources in one job

startUrls is a list — mix subreddits, users, keyword searches and raw URLs freely in one run. Each entry is processed in turn: the Actor fetches its post listing, pushes each post, fetches that post's comments, then moves to the next entry. Sources run sequentially, not in parallel, so maxPosts and maxCommentsPerPost apply per source, not as a combined total across the whole list.

How does Reddit Trends Scraper & Top Comments work?

The Actor reads old.reddit.com rather than Reddit's modern front end or its .json API endpoints. That choice is deliberate: Reddit's .json comment endpoints returned 403 in testing from both Apify's datacenter and residential proxy pools, while old.reddit.com's server-rendered HTML — for both post listings and comment pages — did not. Requesting a like-for-like URL and parsing the HTML that comes back is the path that actually works from proxied IPs.

Post listings are fetched page by page. The Actor extracts posts with lxml, preferring Reddit's own data-* attributes (data-score, data-author, data-subreddit, data-timestamp, data-fullname) over parsing visible text, because those attributes are still present even when Reddit hides a score from the rendered page — which is why a hidden score comes back null instead of a parsed 0. Post type (subredditType: self or link) is read from the post's own CSS classes rather than assumed. Pagination walks forward using Reddit's after=t3_<postId> cursor, derived from the last post on each page, until maxPosts is reached or a page returns no posts.

Comment pages are fetched per post, at a URL built from the post's permalink with sort, limit and depth query parameters — limit is 500 when expandMoreComments is on and 200 when it's off, and depth is derived from maxCommentDepth (max(2, maxCommentDepth + 1), or 10 when no depth is set) so Reddit inlines enough of the reply tree up front. The Actor then recursively walks the returned commentarea / nestedlisting structure, building one flat record per comment with its real depth and parentId, and stops recursing past maxCommentDepth or once maxCommentsPerPost rows have been collected for that post.

Only publicly visible listing and comment data is read. No account, cookie or session is used at any point.

How does Reddit Trends Scraper & Top Comments handle rate limits and blocking?

Listing pages and comment pages use two different proxy strategies, both routed through Apify Proxy automatically — you do not configure or pay for proxies separately.

Post listings are fetched through Apify's residential proxy pool. A request that returns 403 or 429 is treated as blocked and retried, up to three attempts total, with a short delay between attempts; a page is skipped and logged if all three fail.

Comment pages escalate further: up to three attempts on residential proxy, then one final attempt on a datacenter proxy, each with a fresh proxy session. A response is only accepted if it actually contains a recognizable comment section (commentarea or nestedlisting present in the HTML) — a 200 response with an empty or broken page is treated the same as a failure rather than parsed into zero comments. If every attempt fails, that post's comments are skipped and logged, and the run continues with the next post rather than stopping the whole job.

Both request paths send a full desktop browser header set (matching Chrome's sec-ch-ua, accept, and user-agent values) rather than a bare HTTP client signature, since Reddit's blocking is header-sensitive as well as IP-sensitive.

What are the known limitations of Reddit Trends Scraper & Top Comments?

Stated plainly, rather than left for you to discover mid-run:

• Sources run sequentially, not in parallel. Each entry in startUrls is fully processed — listing pages, then every post's comments — before the next entry starts. A long list of subreddits with includeComments on will take proportionally longer than a single one; there is no configurable concurrency between sources.
• One sortBy applies to the whole run. Post sort order is set once per run and applied to every entry in startUrls — you cannot sort one subreddit by top and another by new in the same job. Run them as separate jobs if you need different sort orders per source.
• Bare keywords need a prefix or a space to be recognized as such. A single word with no / and no space is parsed as a username, not a subreddit or search term — see the input pitfall note below.
• Private, quarantined and login-gated content is out of scope. The Actor reads only what old.reddit.com serves to an anonymous, logged-out visitor — quarantined subreddits and private communities will not return results.
• proxyConfiguration is present in the input schema but not currently read by the code. Proxy selection is handled internally instead — see the input pitfall note and the rate-limit section above.

⬇️ Input

startUrls is the only required field. Every other input has a default and can be left as-is for a first run. There is no login or API key to supply — the Actor reads only public pages.

Parameter	Required	Type	Description	Example Value
startUrls	✅ Yes	array	Reddit listing URLs (e.g. https://www.reddit.com/r/popular/), subreddits (r/popular), usernames (u/spez), or keywords to search. Each source is expanded into posts; each post is then scraped for comments.	["https://www.reddit.com/r/popular/"]
sortBy	No	string	Server-side sort for the post listing: hot, new, top, rising, controversial. Default "hot".	"top"
maxPosts	No	integer	Maximum number of parent POSTS per source. Comments do NOT count toward this limit. Minimum 1. Default 10.	15
includeComments	No	boolean	When enabled, each post's comment tree is fetched and emitted as child rows (type: "comment", isChild: true) interleaved after the parent post. Default true.	true
maxCommentsPerPost	No	integer	Cap on comment rows collected per post (top-level + nested replies combined). Set 0 for unlimited. Minimum 0. Default 10.	25
commentSort	No	string	How Reddit orders comments before they are collected: confidence (Best), top, new, controversial, old, qa. Default "confidence".	"top"
maxCommentDepth	No	integer	How deep to expand nested reply threads. 0 = top-level comments only, 1 = replies to top-level, etc. Minimum 0. Default 3.	2
expandMoreComments	No	boolean	Requests Reddit to inline more collapsed reply branches (a higher fetch limit) so deeper threads are recovered, up to the depth and per-post caps. Default true.	true
proxyConfiguration	No	object	Proxy input for the run. Post listing and comment pages are fetched through Apify's own proxy selection internally — see the pitfall note below.	{"useApifyProxy": false}

Example input

{
  "startUrls": [
    "https://www.reddit.com/r/popular/",
    "r/dataisbeautiful",
    "artificial intelligence layoffs"
  ],
  "sortBy": "top",
  "maxPosts": 10,
  "includeComments": true,
  "maxCommentsPerPost": 20,
  "commentSort": "confidence",
  "maxCommentDepth": 3,
  "expandMoreComments": true
}

Common pitfalls:

• A bare word with no / and no space — e.g. technology on its own — is parsed as a username (u/technology), not a subreddit. Use the r/ prefix (r/technology) to target a subreddit, or add a space to trigger keyword search.
• Keyword entries are only lightly encoded (spaces become +); a keyword containing &, # or other URL-reserved characters can distort the resulting search URL. Stick to plain words and short phrases for reliable keyword searches.
• proxyConfiguration is accepted in the schema but currently has no effect on requests — see the note under Proxy and blocking behavior below.

⬆️ Output

Every row is typed, normalized JSON with the same field names on every run — no HTML in the output, no per-run schema drift. Post rows and comment rows share one dataset and are told apart by type. Export as JSON, CSV, Excel, XML or HTML from the Apify Console, or read the dataset through the Apify API.

Scraped results

A post followed by two of its comments — a top-level comment and a nested reply — showing how parentId and depth chain them together:

[
  {
    "type": "post",
    "isChild": false,
    "parentId": null,
    "title": "Researchers open-source a 4B model that beats 70B on reasoning benchmarks",
    "postUrl": "https://reddit.com/r/technology/comments/1oc7g4x/researchers_opensource_a_4b_model/",
    "upvotes": 8421,
    "comments": 612,
    "subreddit": "r/technology",
    "subredditUrl": "https://reddit.com/r/technology/",
    "subredditType": "self",
    "author": "modelwatcher",
    "authorProfile": "https://reddit.com/user/modelwatcher/",
    "postTime": "2026-07-24 18:02:11",
    "postId": "1oc7g4x",
    "createdAt": "2026-07-24T18:02:11Z",
    "scrapedAt": "2026-07-26T09:14:02Z"
  },
  {
    "type": "comment",
    "isChild": true,
    "commentId": "lm9k2p1",
    "postId": "1oc7g4x",
    "parentId": "1oc7g4x",
    "depth": 0,
    "author": "data_nerd_42",
    "authorProfile": "https://www.reddit.com/user/data_nerd_42/",
    "body": "Benchmark numbers aside, has anyone actually run this locally? Curious about real-world latency.",
    "upvotes": 214,
    "commentUrl": "https://www.reddit.com/r/technology/comments/1oc7g4x/-/lm9k2p1/",
    "createdAt": "2026-07-24T18:20:47Z",
    "isSubmitter": false,
    "scrapedAt": "2026-07-26T09:14:03Z"
  },
  {
    "type": "comment",
    "isChild": true,
    "commentId": "lm9lx88",
    "postId": "1oc7g4x",
    "parentId": "lm9k2p1",
    "depth": 1,
    "author": "modelwatcher",
    "authorProfile": "https://www.reddit.com/user/modelwatcher/",
    "body": "Yes — ran it locally on a single 4090, quantized to 4-bit. Linked the repo in the post.",
    "upvotes": 88,
    "commentUrl": "https://www.reddit.com/r/technology/comments/1oc7g4x/-/lm9lx88/",
    "createdAt": "2026-07-24T18:31:05Z",
    "isSubmitter": true,
    "scrapedAt": "2026-07-26T09:14:03Z"
  }
]

upvotes and the post's comments count return null, not a fake 0, whenever Reddit hides the value on the page rather than rendering it.

Pricing events

Both post rows and comment rows written to the main dataset are billed under the same charged event, post_result — a comment costs the same as a post in this Actor's pay-per-event pricing. The second copy of each comment, written to the free reddit-comments-<runId> mirror dataset, is pushed with no charged event attached at all, so it adds nothing to the run's cost. Check the Actor's Pricing tab on the Apify Store for the current per-event rate.

How can I use the data extracted with Reddit Trends Scraper & Top Comments?

• Community managers and trend scouts pull hot or rising posts from a subreddit list on a schedule and sort by upvotes to catch what's breaking out before it peaks, using subreddit and postUrl to route each hit back to the right community.
• AI engineers and LLM developers feed post and comment rows straight into an agent's context window or index title and body into a vector store, so a model answering "what is r/technology saying about X" is grounded in a live pull rather than training data, with parentId and depth preserved for citation context.
• Market researchers run the same keyword or subreddit list weekly and compare upvotes, comments and comment volume per postId to track how a topic's coverage and reception shift over time, using createdAt to separate genuinely new discussion from older posts still climbing the rankings.
• Content creators and community teams set commentSort to top and read the highest-voted replies on a post to find the exact questions and objections an audience raises, without opening the thread manually — isSubmitter flags which of those replies came from the original poster.

How do you monitor Reddit trends and top comments over time?

Reddit trend monitoring is the practice of re-running the same query set on a schedule and comparing what changes between runs, rather than trusting a single snapshot. A subreddit's "hot" ranking, and a post's comment count and top comments, all move continuously — a one-off run only tells you where things stood at that moment.

Keep startUrls fixed across runs (the same subreddits, users or keywords) so each run is directly comparable to the last, and diff on postId and upvotes to see which posts gained the most traction between runs, or on commentId and depth to spot which threads grew the most new replies. Because maxCommentsPerPost caps rows per post rather than filtering by recency, a post that crosses your cap between runs is a signal in itself — the thread is still actively growing.

A practical loop: schedule a run daily across a fixed list of subreddits sorted by top, keep the previous run's dataset, and on each new run compare upvotes and comments per postId against it — alert when a post's upvotes delta exceeds a threshold you set, or when a commentId you haven't seen before enters a monitored thread's top comments. The same loop works for a keyword instead of a subreddit — swap the startUrls entry for a search phrase and diff on the same fields to track how a topic's coverage evolves rather than how one community behaves. Set this up under the Actor's Schedules tab in the Apify Console — the Actor itself has no built-in scheduler, but any Apify schedule can trigger it on a recurring interval and route the resulting dataset onward from there.

Integrate Reddit Trends Scraper & Top Comments and automate your workflow

Reddit Trends Scraper & Top Comments works with any language or tool that can send an HTTP request, since it runs as a standard Apify Actor.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/reddit-trends-scraper-top-comments").call(run_input={
    "startUrls": ["r/technology"],
    "sortBy": "top",
    "maxPosts": 10,
    "maxCommentsPerPost": 20,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["type"] == "post":
        print(item["title"], item["upvotes"], item["postUrl"])
    else:
        print("  ↳", item["author"], item["body"][:80])

Scheduled monitoring and delivery

Attach a schedule to the Actor from the Apify Console's Schedules tab to run it hourly, daily, or on any cron interval — no code required. For delivery, add a webhook under the Actor's Integrations tab (for example on ACTOR.RUN.SUCCEEDED) to notify your own endpoint once a run's dataset is ready, or poll the run and dataset through the Apify API from your own scheduler.

Is it legal to scrape Reddit posts and comments?

Scraping publicly visible Reddit content is broadly treated as permissible where no login or paywall is bypassed, and Reddit Trends Scraper & Top Comments reads only what an anonymous visitor already sees on a post listing or comment page. Post and comment text, scores, and subreddit metadata are public forum content; author fields (author, authorProfile) carry pseudonymous Reddit usernames, which can constitute personal data under GDPR and CCPA depending on your jurisdiction and how you use them — treat that data accordingly if you store or link it to other identifiers. Separately, Reddit's own terms of service govern automated access to the site regardless of the personal-data question. Scraping for internal monitoring and research carries a different risk profile than scraping to build a training corpus or a republished product — consult your legal team before either, particularly for bulk storage, redistribution, or any use case that links Reddit usernames to real-world identities.

❓ Frequently asked questions

Does Reddit Trends Scraper & Top Comments need a Reddit account or login?

No. The Actor never sends a session cookie, login form, or auth token — it reads only the public HTML of Reddit's post listings and comment pages. The one credential you need is your Apify account.

How do I target a specific subreddit, user, or search term?

Prefix a subreddit with r/ (r/technology) and a username with u/ (u/spez); anything else with no slash and no space is parsed as a username too, so a bare word like technology alone resolves to u/technology, not the subreddit. Type a phrase with a space in it ("ai layoffs") to run a keyword search instead, or paste a full Reddit URL directly.

What is the difference between maxPosts and maxCommentsPerPost?

maxPosts caps parent posts per source; comments never count against it. maxCommentsPerPost caps comment rows per post independently. maxPosts=10 with maxCommentsPerPost=20 can return up to 10 posts and up to 200 comment rows in that source.

How does Reddit Trends Scraper & Top Comments handle Reddit's anti-bot measures?

Every listing and comment request goes through Apify's residential proxy pool with browser-matching headers. Listing pages retry up to three times on failure or a 403/429 response. Comment pages retry up to three times on residential proxy, then fall back to a datacenter proxy for a final attempt, and only accept a response that actually contains a parseable comment section rather than an empty shell.

Does Reddit Trends Scraper & Top Comments mirror comments to a separate free dataset?

Yes. Whenever includeComments is on, every comment written to the main dataset is also written, unmodified and at no extra charge, to a per-run dataset named reddit-comments-<runId> (the run's own ID). Open it through the Apify API or Console to get a comment-only export without filtering the combined dataset yourself.

How many posts and comments does Reddit Trends Scraper & Top Comments return per query?

Per source: up to maxPosts posts (default 10, minimum 1), and up to maxCommentsPerPost comment rows per post (default 10, 0 for unlimited). There is no separate platform-imposed cap beyond that — the Actor pages through Reddit's own listing pagination until it reaches your maxPosts target or runs out of pages.

How do I monitor a subreddit or keyword over time with Reddit Trends Scraper & Top Comments?

Schedule the Actor to run on the same startUrls list at a fixed interval from the Apify Console's Schedules tab, keep each run's dataset, and diff upvotes/comments per postId and new commentId values per thread between runs to see what actually changed since the last pull.

Does Reddit Trends Scraper & Top Comments work with Claude, ChatGPT, and AI agent frameworks?

Yes, as a standard HTTP endpoint. It is callable through the Apify API by any agent framework that can make a request — LangChain, CrewAI, a custom tool definition — which lets an agent retrieve a live Reddit pull before answering rather than relying on stale training data.

How does Reddit Trends Scraper & Top Comments compare to other Reddit scrapers?

Checked on the Apify Store on 26 July 2026: harshmaur/reddit-scraper and betterdevsscrape/reddit-scraper are both much broader — 70+ and dozens of documented fields respectively, covering posts, comments, user profiles and subreddit/community metadata, with MCP and connector integrations on the former. fresh_cliff/reddit-json-api-scraper is a lighter posts-plus-optional-comments scraper with a small, fixed field set. None of the three documents an uncharged, per-run comment-only mirror dataset or null-instead-of-fake-0 handling for hidden vote counts — the two things Reddit Trends Scraper & Top Comments leads with. Choose the broader scrapers when you need user profiles or subreddit metadata in the same run; choose this Actor when your job is posts plus depth-controlled comment threads and you want a free comment-only export alongside them.

Do maxCommentDepth and maxCommentsPerPost interact?

Yes — both caps apply together, and either one can end collection first for a given post. maxCommentDepth bounds how many reply levels deep the recursion goes; maxCommentsPerPost bounds the total row count across all levels combined. A thread with many shallow top-level comments can hit maxCommentsPerPost before maxCommentDepth is ever reached, and a narrow-but-deep thread can hit maxCommentDepth while well under the row cap. Set maxCommentDepth to 0 to collect only top-level comments regardless of how high maxCommentsPerPost is set.

Can I use Reddit Trends Scraper & Top Comments without managing proxies or platform credentials?

Yes. You never create a proxy account or supply Reddit credentials — the Actor always routes listing and comment requests through Apify's own proxy selection (residential, with a datacenter fallback for comment pages) regardless of what is set in the proxyConfiguration input, which currently has no effect on the requests made. The only account you need is your own Apify account.

🔗 Related scrapers

Scraper Name	What it extracts
Facebook Group Keyword Monitor	Posts from a public Facebook group filtered by keyword, tagged with sentiment
Instagram Hashtag Engagement Scraper	Instagram posts and reels by hashtag, ranked by engagement
Twitter X Reply Scraper — Conversation Engagement Analytics	Reply threads on X posts with conversation-level engagement metrics
YouTube Channel Growth Tracker	Subscriber, view and video growth for YouTube channels across re-runs

💬 Your feedback

Found a bug or missing a field? Open an issue on the Actor's Issues tab in the Apify Console. Reports that include the exact input JSON and the source URL or subreddit are the fastest to reproduce and fix.