Pricing

from $0.49 / 1,000 results

Try for free

Go to Apify Store

Reddit Multi-Mode Scraper for Posts, Comments & Profiles

Try for free

Pick one of five modes to pull subreddit posts, full comment threads, user profiles, keyword search results or curated community listings from Reddit, each with deep post/comment filters. No account or API key needed.

Pricing

from $0.49 / 1,000 results

Rating

0.0

(0)

Developer

Nimbryxo-studio

Actor stats

Bookmarked

Total users

Monthly active users

2 days ago

Last modified

Categories

Social media

Automation

Lead generation

You can access the Reddit Multi-Mode Scraper for Posts, Comments & Profiles programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "2.0",
    "x-build-id": "ilFk20SGtzrsuw9Db"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/nimbryxo-studio~reddit-multi-mode-scraper-for-posts-comments/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-nimbryxo-studio-reddit-multi-mode-scraper-for-posts-comments",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK"
          }
        }
      }
    },
    "/acts/nimbryxo-studio~reddit-multi-mode-scraper-for-posts-comments/runs": {
      "post": {
        "operationId": "runs-sync-nimbryxo-studio-reddit-multi-mode-scraper-for-posts-comments",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor and returns information about the initiated run in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/runsResponseSchema"
                }
              }
            }
          }
        }
      }
    },
    "/acts/nimbryxo-studio~reddit-multi-mode-scraper-for-posts-comments/run-sync": {
      "post": {
        "operationId": "run-sync-nimbryxo-studio-reddit-multi-mode-scraper-for-posts-comments",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "inputSchema": {
        "type": "object",
        "required": [
          "mode"
        ],
        "properties": {
          "mode": {
            "title": "Mode",
            "enum": [
              "subreddit",
              "post",
              "profile",
              "search"
            ],
            "type": "string",
            "description": "What to scrape: a subreddit listing, post URLs with comments, a user profile, or keyword search.",
            "default": "subreddit"
          },
          "source": {
            "title": "Data source",
            "enum": [
              "auto",
              "live",
              "archive"
            ],
            "type": "string",
            "description": "auto uses live Reddit first and the Arctic Shift archive for depth/bulk or as a fallback. archive is faster and cheaper but lags live Reddit by several hours; live never uses archive data.",
            "default": "auto"
          },
          "subreddits": {
            "title": "Subreddits",
            "type": "array",
            "description": "Subreddits to scrape (mode=subreddit). Accepts names, r/ names or URLs.",
            "default": [
              "programming"
            ],
            "items": {
              "type": "string"
            }
          },
          "postUrls": {
            "title": "Post URLs or IDs",
            "type": "array",
            "description": "Post URLs, comment URLs, share links or bare post IDs (mode=post).",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "usernames": {
            "title": "Usernames",
            "type": "array",
            "description": "Reddit usernames to scrape (mode=profile). Accepts names, u/ names or profile URLs.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "searchQuery": {
            "title": "Search query",
            "type": "string",
            "description": "Keyword or phrase to search for (mode=search). Reddit search syntax such as \"exact phrase\", author:name, subreddit:name and -exclude is supported by live search.",
            "default": ""
          },
          "maxItems": {
            "title": "Maximum total records",
            "minimum": 1,
            "maximum": 10000,
            "type": "integer",
            "description": "Hard cap on all records pushed by the run, across every target.",
            "default": 50
          },
          "maxPosts": {
            "title": "Maximum posts per target",
            "minimum": 1,
            "maximum": 5000,
            "type": "integer",
            "description": "Posts per subreddit, keyword or profile section.",
            "default": 25
          },
          "maxComments": {
            "title": "Maximum comments",
            "minimum": 0,
            "maximum": 100000,
            "type": "integer",
            "description": "Comments per post, keyword, or profile comment section. 0 disables comment records.",
            "default": 100
          },
          "maxDepth": {
            "title": "Maximum comment depth",
            "minimum": 0,
            "maximum": 20,
            "type": "integer",
            "description": "Deepest reply level to emit (0 = top-level comments only).",
            "default": 6
          },
          "includeComments": {
            "title": "Include comments (mode=post)",
            "type": "boolean",
            "description": "Emit comment records for each post. Disable to fetch only the parent post.",
            "default": true
          },
          "includePost": {
            "title": "Include parent post (mode=post)",
            "type": "boolean",
            "description": "Emit the post record before its comments.",
            "default": true
          },
          "sort": {
            "title": "Sort",
            "enum": [
              "hot",
              "new",
              "top",
              "rising",
              "controversial",
              "best",
              "relevance",
              "comments"
            ],
            "type": "string",
            "description": "Post/listing sort. Search accepts relevance, hot, top, new or comments; other modes use hot, new, top, rising, controversial or best.",
            "default": "hot"
          },
          "timeFilter": {
            "title": "Time filter",
            "enum": [
              "hour",
              "day",
              "week",
              "month",
              "year",
              "all"
            ],
            "type": "string",
            "description": "Time window for top/controversial sorts and search.",
            "default": "day"
          },
          "commentSort": {
            "title": "Comment sort",
            "enum": [
              "confidence",
              "top",
              "new",
              "controversial",
              "old",
              "qa"
            ],
            "type": "string",
            "description": "Comment ordering for mode=post.",
            "default": "confidence"
          },
          "includeNSFW": {
            "title": "Include NSFW (18+) posts",
            "type": "boolean",
            "description": "Include over-18 posts and communities.",
            "default": false
          },
          "includeSubredditInfo": {
            "title": "Include community info (mode=subreddit)",
            "type": "boolean",
            "description": "Emit one community record per subreddit before its posts.",
            "default": false
          },
          "includeSubredditRules": {
            "title": "Include community rules (mode=subreddit)",
            "type": "boolean",
            "description": "Attach posting rules to the community record. Requires includeSubredditInfo.",
            "default": false
          },
          "includeProfileInfo": {
            "title": "Include profile record (mode=profile)",
            "type": "boolean",
            "description": "Emit a profile record with karma, counts and account metadata.",
            "default": true
          },
          "sections": {
            "title": "Profile sections",
            "type": "array",
            "description": "Which history sections to fetch (mode=profile). Allowed values: overview, posts, comments.",
            "items": {
              "type": "string"
            },
            "default": [
              "overview"
            ]
          },
          "searchPosts": {
            "title": "Search posts (mode=search)",
            "type": "boolean",
            "description": "Include post results in keyword search.",
            "default": true
          },
          "searchComments": {
            "title": "Search comments (mode=search)",
            "type": "boolean",
            "description": "Include comment results in keyword search when Reddit's comment tab returns them.",
            "default": false
          },
          "searchCommunities": {
            "title": "Search communities (mode=search)",
            "type": "boolean",
            "description": "Include subreddit matches in keyword search.",
            "default": false
          },
          "searchUsers": {
            "title": "Search users (mode=search)",
            "type": "boolean",
            "description": "Include matching Reddit accounts in keyword search.",
            "default": false
          },
          "withinCommunity": {
            "title": "Restrict search to one community",
            "type": "string",
            "description": "Limit post/comment search to a single subreddit (name, r/name or URL). Required for archive keyword search."
          },
          "maxCommunities": {
            "title": "Maximum community results",
            "minimum": 0,
            "maximum": 1000,
            "type": "integer",
            "description": "Maximum subreddit matches per search query.",
            "default": 10
          },
          "maxUsers": {
            "title": "Maximum user results",
            "minimum": 0,
            "maximum": 100,
            "type": "integer",
            "description": "Maximum account matches per search query.",
            "default": 25
          },
          "onlyNew": {
            "title": "Only new records (incremental runs)",
            "type": "boolean",
            "description": "Emit only records newer than the watermark saved under stateKey by a previous run.",
            "default": false
          },
          "stateKey": {
            "title": "Incremental state key",
            "type": "string",
            "description": "Key-value store key prefix used by onlyNew watermarks.",
            "default": "reddit-mcp-state"
          },
          "failOnEmpty": {
            "title": "Fail when no records are found",
            "type": "boolean",
            "description": "Mark the run FAILED with a clear status message instead of finishing silently with 0 records.",
            "default": true
          },
          "maxProxyBytesMb": {
            "title": "Maximum proxy traffic (MB)",
            "minimum": 0,
            "maximum": 10000,
            "type": "integer",
            "description": "Safety ceiling for paid proxy traffic. The run stops when the ceiling is reached. Images, media and fonts are never downloaded.",
            "default": 50
          },
          "proxyMode": {
            "title": "Connection",
            "enum": [
              "none",
              "datacenter",
              "residential"
            ],
            "type": "string",
            "description": "Direct (no proxy) is the default. Choose datacenter if Reddit blocks your runs. Residential is an explicit last resort and is capped by maxProxyBytesMb.",
            "default": "none"
          },
          "minScore": {
            "title": "Minimum score",
            "minimum": -1000000,
            "maximum": 1000000,
            "type": "integer",
            "description": "Drop posts/comments below this score."
          },
          "maxScore": {
            "title": "Maximum score",
            "minimum": -1000000,
            "maximum": 1000000,
            "type": "integer",
            "description": "Drop posts/comments above this score."
          },
          "minPostComments": {
            "title": "Minimum post comment count",
            "minimum": 0,
            "maximum": 1000000,
            "type": "integer",
            "description": "Drop posts with fewer comments than this."
          },
          "maxPostComments": {
            "title": "Maximum post comment count",
            "minimum": 0,
            "maximum": 1000000,
            "type": "integer",
            "description": "Drop posts with more comments than this."
          },
          "minUpvoteRatio": {
            "title": "Minimum upvote ratio",
            "minimum": 0,
            "maximum": 1,
            "type": "number",
            "description": "Drop posts below this upvote ratio (0-1)."
          },
          "postType": {
            "title": "Post type",
            "enum": [
              "self",
              "link",
              "image",
              "video",
              "gallery",
              "poll"
            ],
            "type": "string",
            "description": "Keep only posts of this type."
          },
          "titleContains": {
            "title": "Title contains",
            "type": "string",
            "description": "Keep only posts whose title contains this text."
          },
          "contentContains": {
            "title": "Body contains",
            "type": "string",
            "description": "Keep only posts whose body/self-text contains this text."
          },
          "flairContains": {
            "title": "Flair contains",
            "type": "string",
            "description": "Keep only posts whose link flair contains this text."
          },
          "authorFlairContains": {
            "title": "Author flair contains",
            "type": "string",
            "description": "Keep only posts whose author flair contains this text."
          },
          "domain": {
            "title": "Link domain contains",
            "type": "string",
            "description": "Keep only posts whose link domain contains this text."
          },
          "authors": {
            "title": "Only these authors",
            "type": "array",
            "description": "Keep posts by these usernames.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "excludeAuthors": {
            "title": "Exclude these authors",
            "type": "array",
            "description": "Drop posts by these usernames.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "excludeKeywords": {
            "title": "Exclude keywords",
            "type": "array",
            "description": "Drop posts whose title, body or flair contains any of these terms.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "excludeStickied": {
            "title": "Exclude stickied posts",
            "type": "boolean",
            "description": "Exclude pinned/stickied posts from results.",
            "default": false
          },
          "excludeRemoved": {
            "title": "Exclude removed posts",
            "type": "boolean",
            "description": "Exclude posts or comments removed by moderators.",
            "default": false
          },
          "excludeCrossposts": {
            "title": "Exclude crossposts",
            "type": "boolean",
            "description": "Exclude crossposts.",
            "default": false
          },
          "excludeSpoilers": {
            "title": "Exclude spoilers",
            "type": "boolean",
            "description": "Exclude posts marked as spoilers.",
            "default": false
          },
          "excludeLocked": {
            "title": "Exclude locked posts",
            "type": "boolean",
            "description": "Exclude locked posts and comments.",
            "default": false
          },
          "excludeDeletedAuthor": {
            "title": "Exclude deleted authors",
            "type": "boolean",
            "description": "Exclude records whose author account was deleted.",
            "default": false
          },
          "excludeArchived": {
            "title": "Exclude archived posts",
            "type": "boolean",
            "description": "Exclude archived posts that no longer accept votes or comments.",
            "default": false
          },
          "onlyWithFlair": {
            "title": "Only posts with flair",
            "type": "boolean",
            "description": "Drop posts without a link flair.",
            "default": false
          },
          "onlyOriginalContent": {
            "title": "Only original content",
            "type": "boolean",
            "description": "Keep only posts tagged as OC.",
            "default": false
          },
          "minAwards": {
            "title": "Minimum awards",
            "minimum": 0,
            "maximum": 1000000,
            "type": "integer",
            "description": "Keep only posts with at least this many awards."
          },
          "minContentLength": {
            "title": "Minimum body length",
            "minimum": 0,
            "maximum": 1000000,
            "type": "integer",
            "description": "Keep only posts whose body is at least this many characters."
          },
          "maxContentLength": {
            "title": "Maximum body length",
            "minimum": 0,
            "maximum": 1000000,
            "type": "integer",
            "description": "Keep only posts whose body is at most this many characters."
          },
          "postedAfter": {
            "title": "Created on or after",
            "type": "string",
            "description": "UTC date lower bound (YYYY-MM-DD)."
          },
          "postedBefore": {
            "title": "Created on or before",
            "type": "string",
            "description": "UTC date upper bound (YYYY-MM-DD), inclusive."
          },
          "restrictSubreddits": {
            "title": "Restrict profile history to subreddits",
            "type": "array",
            "description": "Only keep profile posts/comments made in these subreddits.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "keyword": {
            "title": "Profile keyword filter",
            "type": "string",
            "description": "Only keep profile posts/comments whose title, body or text contains this phrase."
          },
          "minCommunitySubscribers": {
            "title": "Minimum community subscribers",
            "minimum": 0,
            "maximum": 1000000000,
            "type": "integer",
            "description": "Community search only: drop smaller subreddits."
          },
          "maxCommunitySubscribers": {
            "title": "Maximum community subscribers",
            "minimum": 0,
            "maximum": 1000000000,
            "type": "integer",
            "description": "Community search only: drop larger subreddits."
          },
          "minUserKarma": {
            "title": "Minimum user karma",
            "minimum": 0,
            "maximum": 1000000000,
            "type": "integer",
            "description": "User search only: drop accounts with less total karma."
          },
          "maxUserKarma": {
            "title": "Maximum user karma",
            "minimum": 0,
            "maximum": 1000000000,
            "type": "integer",
            "description": "User search only: drop accounts with more total karma."
          },
          "distinguished": {
            "title": "Distinguished posts",
            "enum": [
              "moderator",
              "admin",
              "special",
              "none"
            ],
            "type": "string",
            "description": "Keep only moderator/admin/special posts, or only regular posts."
          }
        }
      },
      "runsResponseSchema": {
        "type": "object",
        "properties": {
          "data": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string"
              },
              "actId": {
                "type": "string"
              },
              "userId": {
                "type": "string"
              },
              "startedAt": {
                "type": "string",
                "format": "date-time",
                "example": "2025-01-08T00:00:00.000Z"
              },
              "finishedAt": {
                "type": "string",
                "format": "date-time",
                "example": "2025-01-08T00:00:00.000Z"
              },
              "status": {
                "type": "string",
                "example": "READY"
              },
              "meta": {
                "type": "object",
                "properties": {
                  "origin": {
                    "type": "string",
                    "example": "API"
                  },
                  "userAgent": {
                    "type": "string"
                  }
                }
              },
              "stats": {
                "type": "object",
                "properties": {
                  "inputBodyLen": {
                    "type": "integer",
                    "example": 2000
                  },
                  "rebootCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "restartCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "resurrectCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "computeUnits": {
                    "type": "integer",
                    "example": 0
                  }
                }
              },
              "options": {
                "type": "object",
                "properties": {
                  "build": {
                    "type": "string",
                    "example": "latest"
                  },
                  "timeoutSecs": {
                    "type": "integer",
                    "example": 300
                  },
                  "memoryMbytes": {
                    "type": "integer",
                    "example": 1024
                  },
                  "diskMbytes": {
                    "type": "integer",
                    "example": 2048
                  }
                }
              },
              "buildId": {
                "type": "string"
              },
              "defaultKeyValueStoreId": {
                "type": "string"
              },
              "defaultDatasetId": {
                "type": "string"
              },
              "defaultRequestQueueId": {
                "type": "string"
              },
              "buildNumber": {
                "type": "string",
                "example": "1.0.0"
              },
              "containerUrl": {
                "type": "string"
              },
              "usage": {
                "type": "object",
                "properties": {
                  "ACTOR_COMPUTE_UNITS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_WRITES": {
                    "type": "integer",
                    "example": 1
                  },
                  "KEY_VALUE_STORE_LISTS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_INTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_SERPS": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              },
              "usageTotalUsd": {
                "type": "number",
                "example": 0.00005
              },
              "usageUsd": {
                "type": "object",
                "properties": {
                  "ACTOR_COMPUTE_UNITS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_WRITES": {
                    "type": "number",
                    "example": 0.00005
                  },
                  "KEY_VALUE_STORE_LISTS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_INTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_SERPS": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Reddit Multi-Mode Scraper for Posts, Comments & Profiles OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Reddit Multi-Mode Scraper for Posts, Comments & Profiles from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Reddit Multi-Mode Scraper for Posts, Comments & Profiles API in Python

Reddit Multi-Mode Scraper for Posts, Comments & Profiles API in JavaScript

Reddit Multi-Mode Scraper for Posts, Comments & Profiles API through CLI

Reddit Multi-Mode Scraper for Posts, Comments & Profiles API

Reddit Scraper ✅ Posts, Comments, Users, Communities | NO LOGIN

peakydev/reddit-scraper-post-comments-users

✅. Reddit scraper for posts, comments, users, listings, communities and more. NO LOGIN Required

Peaky Dev

268

5.0

(20)

Reddit Post Scraper

backhoe/reddit-post-scraper

Extract detailed information from Reddit posts including title, content, media, and hierarchical comment threads. Supports various comment sorting methods and customizable limits.

5.0

(1)

Reddit Community Posts Scraper Pro

getdataforme/reddit-community-posts-actor

Reddit community Posts Scraper Pro is developed and well tested scraper that extracts community posts detail information posted in reddit.com. Feel free to use and make best use of this scraper to meet your need and be on top of your competitors.

GetDataForMe

117

1.0

(3)

Reddit Scraper

scrapingdino/reddit-scraper

Crawl Reddit posts, comments, communities, and user profiles without requiring login. Pay only for the results you get, limit scraping by posts or items, and export complete datasets in multiple formats for easy analysis or integration.

Scraping Dino

5.0

(1)

Reddit Scraper

maximedupre/reddit-scraper

The best Reddit scraper, for both posts & comments.

Maxime Dupré

Reddit API Scraper

comchat/reddit-api-scraper

Reddit Scraper is a powerful tool that allows you to extract data from Reddit such as posts by keyword. With Reddit Scraper, you can easily gather valuable information from Reddit without the need to log in. You can easily use this Reddit scraper as an alternative API.

Comchat

3.2

(6)

Facebook Comments Scraper - Deep, No Login

haketa/facebook-comments-scraper

Scrape comments from public Facebook posts with deep pagination. By post URL, get each comment's author name, profile link, text, like count, timestamp and replies — far beyond the preview comments. No login, no API key, no browser. Export to JSON, CSV or Excel.

Haketa

Reddit Scraper - Posts, Comments & Users

dataharvest/reddit-scraper

Scrape Reddit posts, comments, subreddits and user profiles using the public JSON API.

Alex v

Reddit Posts Scraper — Comments, Replies & Subreddits

khadinakbar/reddit-posts-scraper

Extract Reddit posts, comments and subreddit data with no login. Returns title, score, author, flair, body text and dates for each post.

Khadin Akbar

Reddit: Subreddit Posts Comments Actor

pintostudio/reddit-subreddit-posts-comments-actor

This actor allows you to scrape comments from any Reddit post. Simply provide a Reddit post URL, and the actor will fetch all comments with their metadata including author, score, timestamps, and nested replies.