Reddit Comments Scraper

💬 What is Reddit Comments Scraper?

Reddit Comments Scraper extracts comments from Reddit: the whole text, the score, the author, the date, the post it belongs to, how deep it sits in its thread — one row per comment, ready for a spreadsheet, a database or a model. It works as a Reddit API alternative for comments: run it on a schedule, call it from your code, or plug it into Make, Zapier or n8n.

Give it the posts whose threads you want, a community to follow, a search term, or a user: the sources add up in one run. Click Start and download the rows in JSON, CSV or Excel. No login, nothing to install.

📋 What data can you extract from Reddit comments?

Every row carries the same 229 fields, whatever route found it, so a CSV export stays square: a field a row does not have is null, never missing. The dataType column says what the row is — comment, or post when you ask for the posts too.

Category	What you get
💬 Comment	the whole text, as text and as HTML, its link and its length — "Exactly. Unit tests are done to literally test the modules…"
🧵 Thread	the post it belongs to (title, author, link), the comment it answers and how deep it sits: the whole thread in a spreadsheet
👤 Author	username, flair, badges, and whether they wrote the post
👍 Votes	score, awards, controversy — 61, 0, 0
🕒 Dates	written, edited — 2026-09-18T23:19:53.000Z, what the date filters read
📈 Computed for you	age in hours and score per hour
🧭 How it was found	thread, link to one comment, live feed of a community, history of a user or search — and the source it came from

Every field, with what it holds, is listed in the Output section below.

✅ Why use Reddit Comments Scraper?

• 🧵 Whole threads by default: a post's thread is read to its end, replies included, and the comments Reddit folds behind "load more comments" are unfolded too. postId, parentId, parentKind, depth and replyCount rebuild the tree in any spreadsheet.
• 🧩 Five ways in, one run: post links (or a link to one comment), a community's live comments, the threads of its posts, a search term, a user's history — they add up. No mode to choose, no second run to launch.
• 🎯 Filters made for comments: date of the comment (not of the post), words, authors, score, only the post author's comments, and the top-level comments the post author did or did not answer — to find the questions that stayed open.
• 🧹 No dead weight: deleted and removed comments are neither written nor charged by default, and a row a filter drops is never charged as a comment.
• 🔔 Monitoring built in: tick New comments only, schedule the Actor, and each run returns — and charges — only the comments it has never delivered, on every source.
• 🔌 API, scheduling, webhooks and integrations (Make, Zapier, n8n, Google Sheets, Slack, Airtable…), plus JSON/CSV/Excel export, through the Apify platform.

🚀 How to scrape Reddit comments

1. Create a free Apify account.
2. Open Reddit Comments Scraper and paste the posts you want in Post and comment links, or name a community in Communities (for example programming), or type a Search term, or give a user in Users.
3. Or paste your own Reddit URLs into Any Reddit URLs: a post, a link to one comment, a community, a user profile or a search page. A text file with one link per line loads a long list at once.
4. Empty Search term in the Console unless a search is what you want: the form opens with web scraping in it (an example), and that search would run next to your other sources, charged like any comment.
5. Set Maximum results (100 by default, 0 = no limit), then click Start.
6. Download the dataset in JSON, CSV, Excel or through the API.

💰 How much does it cost to scrape Reddit comments?

This Actor uses pay per event pricing: you pay for the rows you get, and only for those. The Pricing tab shows the price of each event:

• comment-scraped: one event per comment row written. A comment that a filter drops, a deleted or removed comment (by default) and a comment already delivered (New comments only) are never written, so never charged.
• post-scraped: one event per post row, only when you tick Include posts.
• A small start fee per run.
• filter-check: the filters you set (strictSearch included) are applied by the Actor on every comment it reads. Only a comment the filters DROP is charged a small filter fee, on every source (threads, comment search, community feeds, account histories): a comment they keep costs its comment row alone. The filters every run applies — adult content left out and deleted or removed comments left out — are free, and so is Minimum comments of a post, which only spares the reading of a thread.
• residential-fallback: if Reddit turns away the default connection, the run moves to another one on its own, and each request answered that way is charged a small fee — a request Reddit refuses is never charged. If Reddit refuses every connection the run can use without ever answering, it stops within a few minutes instead of retrying for a long time, and returns what it already saved.

Platform usage (compute, proxy) is included in the price.

⚙️ Input

Follow the live comments of a community (empty Search term in the Console first):

{
    "subreddits": ["programming"],
    "maxItems": 200
}

The threads of the latest posts of two communities, only the questions their authors never answered, only what is recent (empty Search term in the Console first):

{
    "subreddits": ["programming", "rust"],
    "subredditSource": "postThreads",
    "maxThreadsPerSubreddit": 25,
    "minComments": 5,
    "opReplyFilter": "unanswered",
    "postedAfter": "7 days",
    "maxItemsPerQuery": 500
}

Search inside the comments of all Reddit, three orders added together:

{
    "query": "rust async",
    "searchSorts": ["new", "relevance", "top"],
    "includeKeywords": ["benchmark"],
    "maxItems": 500
}

Or your own posts, with the post rows next to their comments (empty Search term in the Console first):

{
    "postUrls": [
        "https://www.reddit.com/r/programming/comments/1wjjqc7/",
        "t3_1wjjqc7"
    ],
    "includePosts": true,
    "maxCommentDepth": 3
}

Only the new comments, every day (empty Search term in the Console first):

{
    "subreddits": ["rust"],
    "onlyNew": true,
    "stateKey": "rust-daily"
}

Give at least one source: a post, a Reddit URL, a community, a search term or a user. With none, the Actor runs an example instead of stopping — a search for "web scraping", at most 20 rows — and says so in the log, unless authors or opReplyFilter is set: such a run is refused, with a message that asks for a source.

Field	Notes
postUrls	Posts whose comments you want, one per line: a post link, for example https://www.reddit.com/r/programming/comments/1wjjqc7/, a short redd.it link, a bare post id such as t3_1wjjqc7, or the link of a single comment (that comment and its replies). Each post is read as a full thread.
startUrls	Any Reddit URL, or a text file with one link per line: a post, a community such as https://www.reddit.com/r/programming/, a user profile such as https://www.reddit.com/user/spez/ or a search page such as https://www.reddit.com/search?q=tokio (read as the same comment search as the query field: its term, its community and the order it carries; a page that asks for posts or people is read as a comment search all the same).
query, searchQueries, strictSearch	Search INSIDE the comments of all Reddit for a word or phrase, for example rust async. searchQueries adds more terms, one search each; every term is searched in every community (max 500 searches per run, search pages pasted in startUrls included). strictSearch keeps a comment only if its text holds the whole phrase, case and accents ignored — Reddit also matches the words apart; a comment without the phrase is dropped like any filtered comment.
searchSorts	Reddit stops one comment search after about 250 results for each term and order. Tick several orders to get more: their results are added together and each comment is kept once. The orders are new, relevance and top.
subreddits	Community names without the r/ prefix, for example programming. With a search term, each community is searched on its own (max 500 searches per run). Without one, the comments are read the way the next row says.
subredditSource, maxThreadsPerSubreddit	Only for communities given without a search term. latestComments reads the live comment feed of each community (Reddit keeps about the last 1,000); postThreads opens the threads of the posts picked by the post sort and the time window, and reads them in full, up to maxThreadsPerSubreddit posts per community.
sort	Which posts of a community have their thread read: new, hot, top, rising or controversial. A sort carried by a pasted community URL wins over this setting.
timeFilter	The window of the Top and Controversial post sorts: hour, day, week, month, year or all. To keep the comments of a given period, use the date filters below.
minComments	With the threads of posts: skip the posts that have fewer comments than this, before their thread is read. 0 keeps every post.
usernames	Accounts whose comment history you want, newest first (Reddit keeps about the last 1,000), without the u/ prefix, for example spez.
maxItems, maxItemsPerQuery	Stop after this many rows for the whole run, post rows included, and for each source separately — a post, a search term in each community, a community, a user, a pasted URL. 0 means no limit.
maxCommentsPerPost, maxCommentDepth	Highest number of comments read from one post, replies included (0, the default, reads the whole thread), and how deep into the replies to go.
commentSort	The order a post's comments are read in: top, confidence, new, controversial, old or qa (for AMAs). It decides which comments you get when a cap cuts the thread short: the first ones in the order Reddit shows them — with new, the top-level comments newest first, each followed by its replies, so a recent reply under an old comment comes after that comment, not before the next one.
expandMoreComments, includePosts	Whether to unfold the comments Reddit folds behind "load more comments" (on by default: one more request per group of about 10 of them, up to 200 per post), and whether to add one row per post whose thread is read, next to its comments (off by default, charged on its own).
postedAfter, postedBefore	The date of the COMMENT, not of its post: a date such as 2026-09-01, or a period before now such as 7 days or 24 hours.
includeKeywords, excludeKeywords	Keep a comment only if its text holds one of these words, or drop it if it holds one. Case, accents and invisible characters are ignored, so benchmark matches a text written any way.
authors, excludeAuthors	Keep only the comments written by these accounts, for example spez, or drop the ones written by them, for example AutoModerator.
includeNsfw, skipRemoved, onlySubmitter	Adult content is left out by default. Deleted and removed comments are dropped by default: they carry no text and are neither written nor charged. Only the post's author keeps the comments written by the author of the post they belong to.
opReplyFilter	Judged on the top-level comments of a thread: answered keeps those the post's author replied to, unanswered keeps those that got no reply from them, any judges nothing. It needs a thread, so a live feed, a history, a comment search or a link to one comment cannot be judged and is left out of such a run.
minScore	Keep only the comments whose score reaches this number, for example 1. 0, the default, turns the filter off: comments scored below 0 are kept too.
onlyNew, stateKey, resetState	Monitoring: only the comments never delivered under this memory key, for example rust-daily. resetState forgets the memory once.
customLabels	Free key/value pairs copied onto every row, so rows from several runs can be told apart in one spreadsheet.
proxyConfiguration, maxConcurrency, maxRequestsPerMinute, minRequestIntervalMs, maxRequestRetries, debugLog	Advanced. The proxy is included in the price: leave the default (the residential proxy is not available). The four numbers pace the run, and the last switch makes the log verbose.

📦 Output

One row per comment, and one per post when you tick Include posts. Here is a real comment row, shortened to the columns most people use — the run returns all 229:

{
    "dataType": "comment",
    "id": "pao4nll",
    "fullId": "t1_pao4nll",
    "url": "https://www.reddit.com/r/programming/comments/1wk4lod/comment/pao4nll/",
    "postUrl": "https://www.reddit.com/r/programming/comments/1wk4lod/",
    "body": "Exactly. Unit tests are done to literally test the modules and interfaces of our code in units and make sure that they function as intended with external dependencies patched or mocked out. Not for some arbitrary feeling of random unit tests granting confidence to code changes.",
    "postTitle": "\"the main purpose of unit tests is keeping your code from being violently sh*t on by others\"",
    "postAuthor": "mareek",
    "author": "Glizzy_Cannon",
    "isSubmitter": false,
    "subreddit": "programming",
    "subredditPrefixed": "r/programming",
    "score": 61,
    "totalAwards": 0,
    "ageHours": 300.67,
    "scorePerHour": 0.2,
    "wordCount": 46,
    "isNsfw": false,
    "postId": "1wk4lod",
    "parentId": "t1_panzho7",
    "parentKind": "comment",
    "depth": 1,
    "images": [],
    "publishedAt": "2026-09-18T23:19:53.000Z",
    "isEdited": false,
    "sourceUrl": "https://www.reddit.com/r/programming/comments/1wk4lod/",
    "source": "thread",
    "scrapedAt": "2026-10-01T12:00:00.000Z"
}

You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

All 229 fields

Fields	What they give you
dataType, id, fullId, url, permalink, postUrl, postId, parentId, parentKind, depth, replyCount	Identity and links. The row kind (comment, or post with Include posts), its Reddit ids and the pages a human can open. A comment also carries the post it belongs to, the comment it answers, how deep it sits and how many direct replies it got (empty when the comment was read outside its thread).
title, body, bodyHtml, postTitle, postAuthor, postScore, titleLength, bodyLength, wordCount	Text. The whole text of the comment as written on Reddit (Markdown, line breaks and code indentation kept) and as HTML, with its length and word count — and the title, author and score of its post, so a row reads on its own.
author, authorId, authorFlair, authorFlairBackgroundColor, authorFlairCssClass, authorFlairTextColor, authorFlairType, authorFlairRichtext, authorFlairTemplateId, authorPremium, authorPatreonFlair, authorIsBlocked, isSubmitter, distinguished	Author. Who wrote it, their account id, their flair in that community and the badges Reddit shows next to the name. isSubmitter is true when the author of the comment is the author of the post.
subreddit, subredditPrefixed, subredditId, subredditSubscribers, subredditType	Community of the row. Which community the row comes from, its id, its member count at the time of the run and whether it is public or restricted.
score, upVotes, downVotes, upvoteRatio, scoreHidden, numComments, numCrossposts, numDuplicates, controversiality, viewCount	Votes. The score and the votes Reddit publishes. A fresh comment in a community that hides scores has no score yet (scoreHidden says so) rather than the 1 Reddit puts in its place.
totalAwards, gilded, awards, allAwardings, topAwardedType	Awards. How many awards the row got, which ones, and the raw award objects for anything else.
aiAnalysis, aiLabelMatches, ageHours, scorePerHour, commentsPerHour, engagementTotal, commentToScoreRatio, outboundUrlHost	Computed for you. Figures Reddit does not give: the age in hours and the score per hour of the comment.
flair, flairBackgroundColor, flairCssClass, flairTextColor, flairType, flairRichtext, flairTemplateId, postType, contentCategories, discussionType, suggestedSort	Flair and kind of post. What the post of a thread row is: text, link, image, gallery, video or poll, and its flair with its colours.
isNsfw, isSpoiler, isStickied, isLocked, isArchived, isHidden, isQuarantined, isOriginalContent, isSelf, isVideo, isGallery, isMeta, isCrosspostable, isRobotIndexable, isCreatedFromAdsUi, contestMode, allowLiveComments, mediaOnly, sendReplies, noFollow, pinned, collapsed	Flags. Every true or false Reddit publishes on a row: adult content, pinned, locked, archived, collapsed, and the rest.
collapsedReason, unrepliableReason, removedByCategory, removalReason, banReason, bannedBy, approvedBy, modNote, modReasonTitle, whitelistStatus, treatmentTags	Moderation. Why a row was collapsed, removed or banned, and by whom, when Reddit says so publicly.
domain, linkUrl, urlOverriddenByDest, thumbnail, images, galleryCount, videoUrl, videoDuration, hasMedia, mediaType, media, secureMedia, mediaMetadata, galleryData, preview, postHint, crosspostParent	Link and media of the post. On a post row: the outbound link and its domain, the thumbnail, every image, the hosted video, and the raw media objects. Empty on a comment.
publishedAt, editedAt, isEdited, createdAt	Dates. When it was written and when it was last edited, always ISO 8601 in UTC. These are the dates the date filters read.
source, sourceUrl, searchTerm, rank, customLabels, scrapedAt	How it was found. source says which route read the comment (thread, permalink, communityFeed, user or search), sourceUrl the source it came from, searchTerm the term of a search, your own labels, and the moment it was read.
name, displayName, description, descriptionHtml, publicDescription, publicDescriptionHtml, membersCount, communityIcon, bannerImage, headerTitle, primaryColor, lang, advertiserCategory, submissionType, submitText, suggestedCommentSort, allowImages, allowVideos, allowVideogifs, allowGalleries, allowPolls, allowDiscovery, spoilersEnabled, linkFlairEnabled, originalContentTagEnabled, wikiEnabled, restrictPosting, restrictCommenting, acceptFollowers, allOriginalContent, commentScoreHideMins, rules, ruleDetails, wikiPageNames, wikiPages, stickiedPosts, similarCommunities, username, totalKarma, linkKarma, commentKarma, awardeeKarma, awarderKarma, isGold, isMod, isEmployee, isVerified, hasVerifiedEmail, hideFromRobots, iconImg, snoovatarImg, profileTitle, profileDescription, headerImg, keyColor, bannerBackgroundImage, mobileBannerImage, emojisEnabled, previousNames, isSuspended, trophies, profileUrl, bio, isCakeDay, hasSubscribed, allowPredictions, allowPredictionContributors, allowPredictionsTournament, allowTalks, allowedMediaInComments, commentContributionSettings, bannerBackgroundColor, bannerSize, headerSize, iconSize, emojisCustomSize, collapseDeletedComments, communityReviewed, disableContributorRequests, freeFormReports, hasMenuWidget, hideAds, isCrosspostableSubreddit, publicTraffic, shouldArchivePosts, shouldShowMediaInCommentsSetting, showMedia, showMediaPreview, userFlairEnabledInSr, canAssignLinkFlair, canAssignUserFlair, linkFlairPosition, userFlairPosition, submitLinkLabel, submitTextLabel, submitTextHtml	Community and profile columns. The columns that describe a whole community (description, members, icons, settings, rules) or a user profile (karma, badges, bio). A row of this Actor is a comment or a post, so they stay null: they are there so that every row, here and in other Reddit tools, keeps the same shape.

💡 Tips

How to get more results

Reddit stops any single list at about 1,000 comments, and a comment search at about 250 per term and order, whatever the cap you set. To go past it, split the run: several communities instead of one, several search terms, the three search orders added together, the threads of posts (postThreads) instead of the live feed, or a longer postedAfter window read in several runs. Set Maximum results (100 by default, 0 = no limit) to take everything a source has.

How to reduce costs

You pay per comment, so the levers are the caps (maxItems, maxItemsPerQuery, maxCommentsPerPost), the filters — a comment a filter drops costs only its small filter fee, a comment it keeps costs none — and onlyNew for recurring runs, which never charges the same comment twice. The post rows are charged on their own: leave Include posts off when you only want the comments.

The comment tree, in a spreadsheet

Each comment is a row of its own. postId says which post it belongs to, parentId and parentKind say what it answers (the post itself, or another comment), depth says how deep it sits and replyCount how many direct replies it got. Sort by postId then by the order the rows came in and you have the thread as it reads on the site. Use maxCommentDepth to keep only the top-level answers, and maxCommentsPerPost to bound the cost of a very busy thread. A comment read in a live feed or in a user's history comes without its thread: its depth is 0 when it answers the post and empty otherwise, and its replyCount is empty.

Which comments the post author answered

Set Replies from the post's author (opReplyFilter) to unanswered to list the questions that stayed open, or to answered to read how an author reacted. The Actor reads each thread to its full depth to judge, whatever maxCommentDepth says, and writes the top-level comments only; maxCommentsPerPost then caps the rows written.

Monitoring: only the new comments

Tick New comments only (onlyNew) and schedule the Actor. The first run returns everything; each later run skips what it has already delivered: those rows are not saved and not charged. The memory lives in a named key-value store of your account (reddit-comments-scraper-seen, up to 150,000 rows per key) and is only updated with rows that really reached the dataset, so a failed run never hides anything. Give each schedule its own stateKey — two schedules sharing a key would hide each other's rows — and tick resetState once to start over. A community's comment feed and a user's history come newest first: with onlyNew the run stops once it meets 200 rows in a row that you already have (fewer when Maximum results is lower, or when the earlier runs delivered fewer rows from that source: 80 % of that number, met anywhere in the run). A comment your filters dropped is remembered too, on every source (same filters, same stateKey): the next runs neither check nor charge it again. Not remembered, because they can pass later or for another term: a comment dropped for its score, for postedBefore, by strictSearch or by the answered-by-the-author filter. The threads of posts are always read in full, so a comment written under an old post is found.

Filter by the date of the comment

postedAfter and postedBefore take a date (2026-09-01, the whole day included, UTC) or a period before now (7 days, 2 weeks, 1 month, 24 hours). They read the date of the COMMENT, so an old post still gives its recent comments; a comment without a date is dropped as soon as a bound is set. Filtered-out comments are not saved and do not count in maxItems (the filter fee, see Pricing), and the run summary says how many there were. With postedAfter, a comment feed or a history stops at the first page that is entirely too old, and so does a comment search read in the new order, on the date each result prints on the search page; the relevance and top orders are not sorted by date and are read to their end. One recent comment on a page is enough to keep reading.

🔌 Integrations and API

Call the Actor through the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool.

🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the Apify MCP server, billed to their Apify account like any run. It returns one item per Reddit comment (dataType says comment, or post with Include posts). Actor id: nice_dev/reddit-comments-scraper; MCP server with this Actor only: https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/reddit-comments-scraper.

Smallest input, for a cheap first call (empty Search term in the Console first; a call through the API or MCP does not carry it):

{
    "subreddits": ["programming"],
    "maxItems": 10
}

Key output fields: dataType, url, body, author, subreddit, score, publishedAt, postTitle, postId, depth and source.

Cost: one event per comment (and per post row with Include posts), plus a small start fee; the filters you set, the fallback connection and the posts cost extra as the pricing section above says. Cap each call with maxItems and, through the API, with the run option maxTotalChargeUsd.

❓ FAQ

Is it legal to scrape Reddit comments?

The Actor only reads what Reddit shows publicly to any anonymous visitor. It logs in to nothing, uses no account, and solves no captcha. Results contain content written by people under a pseudonym — personal data protected by GDPR: do not store it without a legitimate reason, and keep in mind that a pseudonym can still identify someone. You are responsible for using the data in compliance with Reddit's Terms of Use, its User Agreement and applicable law — in particular if you train a model on it or republish it. This Actor is not affiliated with Reddit.

Does it need a login or a proxy?

No login and no account. The proxy is included in the price: leave the default setting (the residential proxy is not available). A request Reddit turns away moves the run to a new IP with a new session and is tried again at once, without using up its retries (10 times at most per request), as long as the run has an IP left: 8 in all with the default setting, 10 with your own proxies. Past them, a run whose last connection never got an answer stops, with what it already saved; a connection that worked and is refused later, or a run without a proxy, waits before each retry: 5 seconds, doubled at each try, 255 seconds at most.

Is the data safe to open in Excel or to show on a web page?

Comments are what the authors wrote, copied as they are. A text can begin with -, +, = or @: Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value — when you open a CSV, import these columns as text. Every URL column holds an http(s) address or null, never anything a browser would execute. bodyHtml holds the site's own HTML, which the Actor does not sanitize: escape every field like any text written by a stranger before you put it on a web page.

Known limitations

• Reddit stops any single list at about 1,000 comments and a comment search at about 250 per term and order. The Tips section says how to go past it.
• The thread of a very busy post is cut by maxCommentsPerPost and maxCommentDepth. The "load more comments" placeholders are followed with Unfold hidden comments, up to 200 requests (about 1,000 folded comments) per post, as long as the post's own time allows; "continue this thread" links are not.
• A comment found in a live feed or a history comes without its thread: no reply count, and no depth unless it answers the post. The post's score and the community's member count are empty on such a comment.
• A comment found by a search comes without its thread too (no reply count, and no depth unless it answers the post), but with its post's title, link, author and score — empty when Reddit has removed the post since.
• onlyNew remembers row ids, not their content: a comment whose score changed is not returned again.
• Two runs sharing the same stateKey at the same time may both return the same new comment.
• A deleted account is written as [deleted] and a removed text as [removed]: that is what Reddit itself serves. They are dropped by default.

A run that reaches its timeout stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with onlyNew, remembered, and the run ends Succeeded with "Stopped before the run's timeout". Resurrect it to go on from there, or give the next run a longer timeout (Run options).

A run the platform stops without warning (out of memory)

• Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the rows already saved are skipped: none is delivered or charged twice, and maxItems still counts them.
• With onlyNew, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the rows it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the rows of its last 2 seconds once more.

Something doesn't work?

The last line of the log counts the comments saved, the comments filtered out, the posts no longer on Reddit (deleted while the run was reading them) and the requests that failed after every retry. Those requests and the deleted posts are listed, with the reason, in the FAILED_REQUESTS record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause. A source Reddit does not serve — a private, members-only, quarantined or banned community, a suspended account — is skipped with a warning in the log, never a failed request: the run goes on with the other sources and the last line says "1 source of the input not found (see the log)" ("2 sources…" and so on); when it is the only source the run ends Succeeded and its last message names the cause. Without a proxy, when Reddit refuses the Actor's own address, the last message says so and asks you to keep the proxy on instead of "run it again". A community name that does not exist is answered by Reddit with an empty page: the run then ends Succeeded with "No comments found — 0 comments saved — …" ("No new or matching comments" when your filters or New comments only left nothing), so check the spelling.

If Reddit changes its pages, you are told instead of paying for blank rows. A page that counts rows but gives none the Actor can read is an error (listed in FAILED_REQUESTS), never a quiet "No comments found". If the first 20 rows read all lack their author, their community, their publication date or, for a comment, its text (or, for a post, its score), the run saves nothing more, stops and fails, and its last message names the missing field: at most those first rows are charged. A comment that postedAfter / postedBefore drops because it has no date at all counts among those 20.

🛟 Support

Open an issue in the Issues tab with a link to your run: the run log and the FAILED_REQUESTS record of the key-value store show exactly which URLs failed and why.