The mcp-reddit server enables scraping and querying Reddit content without API keys, with local data persistence and media downloads.
Scraping Capabilities:
Scrape posts, comments, and media from subreddits with configurable limits (up to 100 posts by default)
Scrape user profile post history and activity
Fetch specific posts by URL with complete comment threads
Download images, videos, and galleries (videos with audio require ffmpeg)
Querying & Search:
Query previously scraped posts and comments with filters for post type (text, image, video, gallery, link), minimum score/upvotes, and keywords
Full-text search across all stored posts and comments
Retrieve top-scoring posts from scraped sources
List all scraped subreddits and users
Data Storage:
All content persists locally in ~/.mcp-reddit/data/ (customizable) for offline access and repeated queries
Deployment:
Run locally via stdio (for Claude Desktop/Code) or expose as HTTP/SSE server for remote clients
No authentication required—works by scraping old.reddit.com and Libreddit mirrors
Scrapes posts, comments, and media from subreddits and user profiles without requiring API keys, with support for local data persistence, filtering, and search across scraped content.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Reddit Scraper scrape the top 20 posts from r/technology"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for scraping Reddit - no API keys required.
Scrapes posts and comments from subreddits and user profiles using Reddit's public RSS/Atom feeds.
What changed in v0.4.0: Reddit shut down unauthenticated .json access in May 2026,
which broke this project (and every other keyless Reddit scraper). v0.4.0 pivots to
Reddit's still-public .rss feeds. Still zero API keys - but RSS exposes less data:
no scores, upvote ratios, comment counts, NSFW flags, or comment threading.
Those fields were removed from the data model. Comments are flat, up to 100 per post.
No API keys - Uses public RSS feeds, no Reddit API credentials needed
Posts & comments - Titles, authors, timestamps, selftext, flat comment bodies
Image previews - Downloads preview images (videos unavailable via RSS)
Local persistence - Query scraped data offline
Filtering - By post type and keywords
Related MCP server: Reddit Buddy MCP
pip install mcp-redditOr with uvx:
uvx mcp-redditFor local MCP clients like Claude Desktop and Claude Code:
uvx mcp-redditFor remote MCP clients that connect via URL:
uvx mcp-reddit --http --port 8000Options:
--http - Run in HTTP/SSE mode instead of stdio
--host - Host to bind to (default: 0.0.0.0)
--port - Port to listen on (default: 8000, or PORT env var)
The server exposes:
GET /sse - SSE endpoint for MCP connection
POST /messages/ - Message endpoint
GET /health - Health check
Add to your Claude Desktop or Claude Code settings:
~/Library/Application Support/Claude/claude_desktop_config.json)Claude Desktop doesn't inherit your shell PATH, so you need the full path to uvx:
# Find your uvx path
which uvxThen use the full path in your config:
{
"mcpServers": {
"reddit": {
"command": "/Users/YOUR_USERNAME/.local/bin/uvx",
"args": ["mcp-reddit"]
}
}
}Replace /Users/YOUR_USERNAME/.local/bin/uvx with the output from which uvx.
claude mcp add reddit -- uvx mcp-redditOr manually in ~/.claude.json:
{
"mcpServers": {
"reddit": {
"command": "uvx",
"args": ["mcp-reddit"]
}
}
}Tool | Description |
| Scrape newest posts from a subreddit |
| Scrape posts from a user's profile |
| Fetch a specific post by URL (supports image download) |
| Query stored posts with filters |
| Query stored comments |
| Search across all scraped data |
| List all scraped subreddits/users |
get_top_postswas removed in v0.4.0 - RSS feeds expose no scores to rank by. Calling it returns a JSON error pointing toget_posts(newest first) orsearch_reddit.
"Scrape the latest 50 posts from r/LocalLLaMA"
"Fetch this post and download the image: https://reddit.com/r/ClaudeAI/comments/abc123/title"
"Search my scraped data for posts about 'fine-tuning'"Data is stored in ~/.mcp-reddit/data/ by default.
Data scraped with pre-v0.4.0 versions is migrated to the new (narrower) schema
automatically on the next scrape of that subreddit/user - existing posts and
comments stay queryable, and the original file is preserved as *.pre-rss.bak.
Set MCP_REDDIT_DATA_DIR environment variable to customize:
{
"mcpServers": {
"reddit": {
"command": "/Users/YOUR_USERNAME/.local/bin/uvx",
"args": ["mcp-reddit"],
"env": {
"MCP_REDDIT_DATA_DIR": "/path/to/your/data"
}
}
}
}Built on top of reddit-universal-scraper by @ksanjeev284 - a full-featured Reddit scraper with analytics dashboard, REST API, and plugin system.
MIT
Retrieve comments from scraped posts. Returns comment threads with scores and metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Subreddit or username to get comments from | |
| is_user | No | Whether target is a username (default: false) | |
| limit | No | Maximum number of comments to return (default: 100) | |
| min_score | No | Minimum comment score filter | |
| search_query | No | Search for comments containing this text |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds moderate value by mentioning return of comment threads with scores and metadata. However, it does not disclose behavioral traits like pagination, rate limits, or reliance on prior scraping.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no fluff, making it highly concise while conveying the core purpose and output.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 5 parameters, no output schema, and annotations present, the description provides basic context but lacks details on ordering, prerequisites (e.g., need to scrape first), or how the tool interacts with sibling scraping tools. It is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so each parameter is described in the schema. The tool description adds no additional meaning beyond what the schema provides, resulting in a baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Retrieve' and the resource 'comments from scraped posts', and it distinguishes itself from sibling tools like get_posts by specifying it deals with comments and includes 'scores and metadata'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving comments from previously scraped posts but does not explicitly state when to use this tool versus alternatives like search_reddit or scrape_subreddit. No when-not-to-use or prerequisite information is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve scraped posts from local database with optional filters. Use this to access previously scraped data.
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Subreddit or username to get posts from | |
| is_user | No | Whether target is a username (default: false) | |
| limit | No | Maximum number of posts to return (default: 50) | |
| min_score | No | Minimum post score/upvotes filter | |
| post_type | No | Filter by post type: text, image, video, gallery, link | |
| search_query | No | Search for posts containing this text in title or body |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds no extra behavioral context. No mention of authentication or result format, but annotations cover the safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two-sentence description, front-loaded with purpose, no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Missing output format details (no output schema), but for a retrieval tool with good annotations and schema, it is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for all 6 parameters. Description adds no additional parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Retrieve' and resource 'scraped posts' from a local database. It distinguishes from siblings like get_comments (different resource) and scrape_* tools (different action).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies use after scraping to access data. Does not explicitly exclude when to avoid, but sibling names provide enough context for differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get top posts by score from a scraped subreddit or user. Great for finding popular content.
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Subreddit or username | |
| is_user | No | Whether target is a username (default: false) | |
| limit | No | Number of top posts to return (default: 25) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds that it operates on scraped data and returns top posts by score, which is useful behavioral context beyond the annotations. It does not, however, disclose any rate limits or data staleness concerns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no wasted words. However, 'Great for finding popular content' is somewhat generic and could be replaced with more specific guidance. Overall, it is front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and moderate complexity (3 params), the description adequately states what it does and the source of data. It does not describe the return format (e.g., a list of posts with titles, scores, etc.), which leaves some ambiguity about what the agent will receive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema coverage is 100%, so the baseline is 3. The description does not add any additional meaning to the parameters beyond what the schema provides (target, is_user, limit). The phrase 'by score' hints at ordering but is not parameter-specific.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves top posts by score from a scraped subreddit or user, with a specific verb 'Get' and resource 'top posts'. It implies popularity filtering, differentiating from 'get_posts' which likely returns all posts. However, it doesn't explicitly contrast with siblings like 'search_reddit'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes 'Great for finding popular content' as a use case, but provides no explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned among the seven sibling tools, leaving the agent to guess when to use this over 'get_posts' or 'scrape_subreddit'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all subreddits and users that have been scraped. Shows available data sources.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the detail that it shows 'available data sources', which is consistent but does not reveal additional behavioral traits (e.g., pagination, caching). No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two short sentences that front-load the action and resource. Every word adds clear value; no unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (no parameters, no output schema, and clear annotations), the description adequately conveys its purpose. It could optionally mention the return format, but the current information is sufficient for an agent to understand when to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so baseline is 4. The description correctly does not mention parameters as there are none, meeting the expectation for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'list' and the specific resources 'subreddits and users that have been scraped', distinguishing it from sibling tools like get_comments and scrape_subreddit. It leaves no ambiguity about the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for obtaining an overview of scraped sources, but it does not explicitly state when to use it versus other tools, nor does it provide exclusions or alternatives. Usage context is implied but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a specific Reddit post by URL. Returns the post data and all comments.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Reddit post URL (e.g., https://reddit.com/r/sub/comments/id/title) | |
| scrape_comments | No | Whether to fetch comments (default: true) | |
| download_media | No | Whether to download images and videos (default: false) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description says 'Fetch' (read-only behavior), but annotations set readOnlyHint=false, creating a contradiction. No additional behavioral traits beyond the contradiction are disclosed (e.g., rate limits, auth, side effects).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, direct and front-loaded. Every word adds value. No fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but description does mention return type (post data and comments). However, lacks details on comment structure or pagination. For a 3-parameter tool with full schema coverage, it's adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear parameter descriptions. The description adds no extra meaning beyond the schema; it only states the return type. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it fetches a specific Reddit post by URL, and distinguishes from siblings like get_posts (which likely fetches multiple) and scrape_subreddit (subreddit-level). Verb and resource are specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies use when you have a specific post URL, but lacks explicit guidance on when to use alternatives like get_comments for only comments, or when not to use. No exclusions or prerequisites mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scrape posts from a subreddit. Returns post data including titles, authors, scores, comments, and media URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| subreddit | Yes | Name of the subreddit to scrape (without r/) | |
| limit | No | Maximum number of posts to scrape (default: 100) | |
| download_media | No | Whether to download images and videos (default: false) | |
| scrape_comments | No | Whether to scrape comments (default: true) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false and destructiveHint=false, but the description does not clarify whether the tool modifies state or requires special permissions. The term 'scrape' could imply fetching and possibly storing, but this is not explicitly stated. The description adds some context beyond annotations by mentioning the return data fields, but fails to disclose key behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that quickly communicates the tool's purpose. It is front-loaded with the key action and resource. However, it could be slightly more structured by separating the return data description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 4 parameters, no output schema, and weak annotations, the description is too sparse. It does not explain the scraping behavior (e.g., whether it stores data), pagination, rate limits, or error handling. The agent lacks sufficient context to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema; it merely lists return fields without connecting them to parameters. Since the schema already defines parameters well, the description adds minimal value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool scrapes posts from a subreddit and returns relevant data. It is specific about the resource (subreddit) and action (scrape). However, it does not differentiate from sibling tools like 'get_posts' or 'get_top_posts' which might serve similar purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, limitations, or when not to use it, leaving the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scrape posts from a Reddit user's profile. Returns their post history with metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | Reddit username to scrape (without u/) | |
| limit | No | Maximum number of posts to scrape (default: 50) | |
| download_media | No | Whether to download images and videos (default: false) | |
| scrape_comments | No | Whether to scrape comments (default: false) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description says 'scrape' implying read-only, but annotations set readOnlyHint=false, creating slight ambiguity. No behavioral details like rate limits or pagination are disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that is efficient and to the point, though it could be slightly expanded to cover parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, but the description does not explain what metadata is returned. It also omits mention of the limit, media download, and comment scraping features, making it incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (all parameters documented), so baseline is 3. The description adds no extra meaning beyond repeating 'post history with metadata'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it scrapes posts from a Reddit user's profile, distinguishing it from sibling tools like scrape_subreddit. However, it only mentions posts, not comments, even though the schema includes a scrape_comments parameter.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like get_posts or search_reddit. There is no mention of context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search across all scraped Reddit data for posts or comments matching a query. Useful for finding specific topics or trends.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query to find in posts and comments | |
| search_in | No | What to search: posts, comments, or both (default: both) | both |
| limit | No | Maximum number of results (default: 50) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that it searches 'across all scraped Reddit data', which is useful context but does not elaborate on rate limits, authentication, or response structure. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loading the action and purpose. Every sentence adds value with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, and the description does not explain return format, pagination, or sorting behavior. For a search tool, this information would enhance completeness. Otherwise, the tool is straightforward with clear parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with clear descriptions for each parameter (query, search_in, limit). The description does not add further meaning beyond what the schema provides, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'search' and the resource 'all scraped Reddit data'. It specifies what is searched (posts or comments) and provides a use case ('finding specific topics or trends'). This distinguishes it from sibling tools like get_posts or scrape_subreddit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says 'Useful for finding specific topics or trends' which implies when to use, but does not explicitly state when not to use or compare with siblings like get_posts or scrape_subreddit. No guidance on alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
get_commentsget_postsget_top_postslist_scraped_sourcesscrape_postscrape_subredditscrape_usersearch_redditScored across 8 tools
Each tool targets a distinct action (scrape vs. retrieve) and resource (subreddit, user, post, comments, sources). The scrape_* tools clearly handle live fetching while get_* and search_* handle local data.
Tool names follow a consistent verb_noun pattern: scrape_subreddit, scrape_user, scrape_post, get_posts, get_comments, get_top_posts, list_scraped_sources, and search_reddit. The naming scheme is predictable and uniform.
8 tools is well-scoped for a Reddit scraper server, covering both ingestion (scraping) and retrieval (querying local data) without unnecessary bloat.
The tool set covers core scraping from subreddits, users, and individual posts, plus retrieval/search of stored data. Minor gaps like deleting scraped data or listing comments per post directly are absent, but the main workflows are complete.
Browse and manage Reddit posts, comments, and threads. Fetch user activity, explore hot/new/rising…
Reddit posts, comments, search, users & subreddits as JSON via Apify. No Reddit API key. $2/1k
Reddit posts, comments, search, users & subreddits as JSON via Apify. No Reddit API key. $1.50/1k
Reddit MCP server: search posts, subreddit feeds, comments & user profiles as JSON. No API key.