Pricing

$19.99/month + usage

Reddit Scraper

Extract posts, comments, and subreddit data with the Reddit Scraper. Collect post titles, descriptions, upvotes, comment counts, subreddit names, and author usernames automatically. Ideal for trend discovery, community research, and social media analysis.

Pricing

$19.99/month + usage

Rating

0.0

(0)

Developer

Scrapio

Actor stats

Bookmarked

Total users

Monthly active users

22 days ago

Last modified

Categories

Social media

Automation

Developer tools

You can access the Reddit Scraper 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 Integrations settings in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "4Xl4gtGGLDlnnjQE5"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/scrapio~reddit-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-scrapio-reddit-scraper",
        "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/scrapio~reddit-scraper/runs": {
      "post": {
        "operationId": "runs-sync-scrapio-reddit-scraper",
        "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/scrapio~reddit-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-scrapio-reddit-scraper",
        "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": [
          "startUrls"
        ],
        "properties": {
          "startUrls": {
            "title": "🔗 Start URLs",
            "type": "array",
            "description": "One or more Reddit URLs to scrape. This field supports bulk input: use \"+ Add\" to add more URLs, \"Bulk edit\" to paste many at once, or \"Text file\" to upload a file with one URL per line. Accepted URL types: (1) Post URLs — any link containing /comments/ and a post ID (e.g. https://www.reddit.com/r/subreddit/comments/ABC123/title/); (2) Subreddit URLs — links to a community (e.g. https://www.reddit.com/r/python/); (3) User profile URLs — links to a user (e.g. https://www.reddit.com/user/username/). The actor detects the type of each URL and runs the appropriate scraper (post+comments, subreddit listing, or user profile). At least one Start URL is required unless you run in search-only mode with \"Ignore start URLs\" enabled.",
            "items": {
              "type": "string"
            }
          },
          "skipComments": {
            "title": "💬 Skip comments",
            "type": "boolean",
            "description": "If enabled, the actor will not fetch comments for any post URLs. Only the post title, body, score, and other post-level data will be collected. Use this to speed up runs or reduce output size when you only need post content.",
            "default": false
          },
          "skipUserPosts": {
            "title": "👤 Skip user posts",
            "type": "boolean",
            "description": "If enabled, any user profile URLs in Start URLs are ignored and no user data (profile, submitted posts, comments) is scraped. Subreddit and post URLs are still processed as usual.",
            "default": false
          },
          "skipCommunity": {
            "title": "🏘️ Skip community",
            "type": "boolean",
            "description": "If enabled, the actor will not fetch subreddit/community metadata (e.g. description, subscriber count, creation date) for subreddits that appear in your Start URLs or in the subreddit info options. Post listings from those subreddits are still scraped when \"Enable subreddit posts\" is on.",
            "default": false
          },
          "searchTerms": {
            "title": "🔎 Search Term",
            "type": "array",
            "description": "One or more search phrases to run against Reddit. Use \"+ Add\" to add another term or \"Bulk edit\" to paste multiple lines. Each term is queried separately and results appear under the \"search\" key in the output, with the query as the key (e.g. \"python programming\"). Search is executed only when this array is non-empty and either you have no Start URLs or \"Ignore start URLs\" is enabled.",
            "items": {
              "type": "string"
            }
          },
          "searchCommunity": {
            "title": "🏘️ Community (optional)",
            "type": "string",
            "description": "Optional subreddit name without the \"r/\" prefix (e.g. python, learnprogramming). When set, search is restricted to this community only (Reddit's \"search within subreddit\" behaviour). Leave empty to search all of Reddit. Only has an effect when you have at least one Search Term."
          },
          "ignoreStartUrls": {
            "title": "⏭️ Ignore start URLs",
            "type": "boolean",
            "description": "When enabled, the actor does not scrape any Start URLs. Only search runs, using the Search Term(s) you provided. Useful when you want to run a search-only job (e.g. multiple keywords) without scraping specific posts or subreddits. You must provide at least one search term for the run to do anything.",
            "default": false
          },
          "searchForPosts": {
            "title": "📝 Search for posts",
            "type": "boolean",
            "description": "Include posts in search results. When on (default), search returns post listings matching your query. This is the primary search mode for this actor.",
            "default": true
          },
          "searchForComments": {
            "title": "💬 Search for comments",
            "type": "boolean",
            "description": "Reserved for future use: include comments in the search scope. Currently the actor focuses on post search.",
            "default": false
          },
          "searchForCommunities": {
            "title": "🏘️ Search for communities",
            "type": "boolean",
            "description": "Reserved for future use: include communities/subreddits in the search scope.",
            "default": false
          },
          "searchForUsers": {
            "title": "👤 Search for users",
            "type": "boolean",
            "description": "Reserved for future use: include user profiles in the search scope.",
            "default": false
          },
          "sortSearch": {
            "title": "📊 Sort search",
            "enum": [
              "relevance",
              "new",
              "hot",
              "top",
              "comments"
            ],
            "type": "string",
            "description": "Controls how Reddit search results are ordered. Options: relevance (best match to query), new (newest first), hot (trending), top (highest score), comments (most comments). Applies to all search terms in this run.",
            "default": "new"
          },
          "timeFilter": {
            "title": "⏱️ Time filter",
            "enum": [
              "hour",
              "day",
              "week",
              "month",
              "year",
              "all"
            ],
            "type": "string",
            "description": "Restricts search results to a relative time window: hour (last 24h), day, week, month, year, or all (no time limit). This is Reddit's \"t\" parameter and affects which posts are included in search. Use \"Filter by date\" below for an absolute or custom relative date.",
            "default": "all"
          },
          "filterByDate": {
            "title": "📅 Filter by date (Posts only)",
            "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$|^$",
            "type": "string",
            "description": "Optional filter to only include posts from a certain date onward. You can choose an absolute date (e.g. 2024-01-15) or a relative range (e.g. \"3 days\", \"2 weeks\", \"1 month\"). Leave empty to not filter by date. Applies to search and listing results where applicable."
          },
          "enableSearch": {
            "title": "🔍 Enable search",
            "type": "boolean",
            "description": "When on, the actor will run Reddit search if you have provided Search Terms and are in search mode (no Start URLs or Ignore start URLs). When off, search is skipped even if search terms are present.",
            "default": true
          },
          "enableSubreddit": {
            "title": "📰 Enable subreddit posts",
            "type": "boolean",
            "description": "When on, any subreddit URLs in Start URLs (e.g. reddit.com/r/python) are scraped for their post listing (hot, new, etc.) up to the limits you set. When off, subreddit URLs are ignored.",
            "default": true
          },
          "sortSubreddit": {
            "title": "📊 Subreddit listing sort",
            "enum": [
              "hot",
              "new",
              "top",
              "rising",
              "controversial"
            ],
            "type": "string",
            "description": "How to order posts when fetching from each subreddit: hot (trending), new (newest first), top (highest score), rising (gaining traction), controversial.",
            "default": "hot"
          },
          "enablePost": {
            "title": "📝 Enable post + comments",
            "type": "boolean",
            "description": "When on, any post URLs in Start URLs are scraped for the full post and its comment tree (unless \"Skip comments\" is enabled). When off, post URLs are ignored.",
            "default": true
          },
          "enableUser": {
            "title": "👤 Enable user scraper",
            "type": "boolean",
            "description": "When on, any user profile URLs in Start URLs are scraped for profile info, submitted posts, and comments (subject to \"Skip user posts\" and limit settings). When off, user URLs are ignored.",
            "default": true
          },
          "enableSubredditInfo": {
            "title": "🏘️ Enable subreddit info",
            "type": "boolean",
            "description": "When on, the actor fetches metadata for subreddits: for subreddits from Start URLs and, if enabled below, popular/new subreddit lists. Metadata includes title, description, subscribers, creation date, etc. When off, no subreddit info is collected.",
            "default": true
          },
          "maxItemsToSave": {
            "title": "📦 Maximum number of items to be saved",
            "minimum": 1,
            "type": "integer",
            "description": "Global maximum number of items (e.g. posts, search results) the actor will collect across all sources. Helps control run duration and dataset size. Each scraper type respects this cap where applicable.",
            "default": 10
          },
          "limitPostsPerPage": {
            "title": "📄 Limit of posts scraped inside a single page",
            "minimum": 1,
            "type": "integer",
            "description": "Maximum number of posts to fetch from a single subreddit listing (e.g. one \"hot\" or \"new\" listing). Reddit returns up to 100 per request; lowering this reduces data per subreddit.",
            "default": 10
          },
          "postDateLimit": {
            "title": "📅 Post date limit",
            "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^$",
            "type": "string",
            "description": "If set, only posts created on or after this date (YYYY-MM-DD) are included. Use the date picker or enter a date. Leave empty to include all posts regardless of date."
          },
          "limitCommentsPerPage": {
            "title": "💬 Limit of comments scraped inside a single page",
            "minimum": 1,
            "type": "integer",
            "description": "Maximum number of comments to retrieve per post. Reddit returns comments in a tree; this limits how many are fetched per post to avoid very large responses.",
            "default": 10
          },
          "limitCommunityPages": {
            "title": "🏘️ Limit of Communities' pages scraped",
            "minimum": 1,
            "type": "integer",
            "description": "For each subreddit/community URL, the maximum number of listing pages to paginate through (each page can contain up to the \"Limit of posts\" value). Use a low number (e.g. 2) for quick runs or higher for more coverage.",
            "default": 2
          },
          "limitUserPages": {
            "title": "👤 Limit of Users' pages scraped",
            "minimum": 1,
            "type": "integer",
            "description": "For each user profile URL, the maximum number of pages to fetch for submitted posts and comments. Each page contains multiple items; this cap controls how deep the actor goes into a user's history.",
            "default": 2
          },
          "pageScrollTimeout": {
            "title": "⏳ Page scroll timeout (seconds)",
            "minimum": 1,
            "type": "integer",
            "description": "Timeout in seconds for any page or scroll-related operations during scraping. If a request or scroll step takes longer than this, it may be aborted. Increase for slow networks.",
            "default": 40
          },
          "maxCommentDepth": {
            "title": "🌳 Max comment tree depth",
            "minimum": 1,
            "maximum": 20,
            "type": "integer",
            "description": "Maximum depth of nested comment replies to parse. Depth 1 means only top-level comments; higher values include more nested threads. Reddit threads can be very deep; limiting depth keeps output manageable (1–20).",
            "default": 5
          },
          "maxItemsPerUser": {
            "title": "👤 Max items per user (posts/comments)",
            "minimum": 1,
            "type": "integer",
            "description": "Per user, the maximum number of submitted posts and the maximum number of comments to fetch. For example, 20 means up to 20 submitted posts and up to 20 comments per user profile.",
            "default": 20
          },
          "fetchUserProfile": {
            "title": "👤 Fetch user profile",
            "type": "boolean",
            "description": "When on, fetch each user's profile (name, karma, created date). When off, only submitted posts and/or comments are fetched according to the toggles below.",
            "default": true
          },
          "fetchUserSubmitted": {
            "title": "📝 Fetch user submitted posts",
            "type": "boolean",
            "description": "When on, fetch posts submitted by each user. When off, only profile and/or comments are fetched according to the other toggles.",
            "default": true
          },
          "fetchUserComments": {
            "title": "💬 Fetch user comments",
            "type": "boolean",
            "description": "When on, fetch comments made by each user. When off, only profile and/or submitted posts are fetched according to the other toggles.",
            "default": true
          },
          "fetchUserOverview": {
            "title": "📋 Fetch user overview",
            "type": "boolean",
            "description": "When on, in addition to profile, submitted posts, and comments, the actor fetches the user's combined overview and adds a summary (total items, posts count, comments count) to the user output. Slightly increases requests per user.",
            "default": false
          },
          "fetchPopularSubreddits": {
            "title": "🔥 Fetch popular subreddits list",
            "type": "boolean",
            "description": "When on, the actor fetches Reddit's list of popular subreddits and adds them to the \"subreddit_info.popular\" array in the output. The number of subreddits is capped by \"Max subreddits (popular/new lists)\" below.",
            "default": false
          },
          "fetchNewSubreddits": {
            "title": "🆕 Fetch new subreddits list",
            "type": "boolean",
            "description": "When on, the actor fetches recently created subreddits and adds them to \"subreddit_info.new\" in the output. The number is capped by \"Max subreddits (popular/new lists)\" below.",
            "default": false
          },
          "maxSubredditsInfo": {
            "title": "🔢 Max subreddits (popular/new lists)",
            "minimum": 1,
            "maximum": 100,
            "type": "integer",
            "description": "When \"Fetch popular subreddits\" or \"Fetch new subreddits\" is enabled, this is the maximum number of subreddits to fetch for each of those lists. Does not affect metadata for subreddits from your Start URLs.",
            "default": 25
          },
          "requestDelaySeconds": {
            "title": "⏳ Delay between requests (seconds)",
            "minimum": 0,
            "type": "integer",
            "description": "Number of seconds to wait between consecutive HTTP requests to Reddit. A value of 1 or 2 can help avoid rate limiting (429). Set to 0 for no delay (faster but higher risk of blocks).",
            "default": 1
          },
          "proxyConfiguration": {
            "title": "🌐 Proxy Configuration",
            "type": "object",
            "description": "Configure Apify Proxy for this run. By default the actor uses no proxy (direct connection to Reddit). If Reddit blocks or rate-limits the run, the actor will automatically try datacenter proxy, then residential proxy (up to 3 retries), and keep using the first one that works. Here you can optionally enable Apify proxy from the start (e.g. use Apify Proxy with a specific group) so all requests go through proxy immediately."
          }
        }
      },
      "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
                  }
                }
              },
              "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Reddit Scraper 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 Scraper 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 Scraper API in Python

Reddit Scraper API in JavaScript

Reddit Scraper API through CLI

Reddit Scraper API

Reddit Scraper

scrapapi/reddit-scraper

Extract posts, comments, and user data from Reddit with the Reddit Scraper. Collect post titles, descriptions, upvotes, comment counts, subreddit names, and author usernames automatically. Ideal for market research, trend discovery, and community analysis.

ScrapAPI

Reddit Scraper

api-empire/reddit-scraper

Extract posts, comments, and user data from Reddit using the Reddit Scraper. Collect post titles, descriptions, upvotes, comment counts, subreddit names, and author details automatically. Ideal for market research, trend analysis, and community insights.

API Empire

Reddit Api Scraper

api-empire/reddit-api-scraper

Extract Reddit data efficiently using the Reddit API Scraper. Collect posts, comments, authors, upvotes, subreddit names, and timestamps through the Reddit API. Ideal for market research, sentiment analysis, community monitoring, and trend discovery.

API Empire

Reddit Api Scraper

scrapio/reddit-api-scraper

Extract structured Reddit data with the Reddit API Scraper. Collect posts, comments, usernames, upvotes, subreddit names, and timestamps directly through the Reddit API. Ideal for market research, sentiment analysis, and community monitoring.

Scrapio

Reddit Posts & Comments Scraper

makework36/reddit-scraper

Scrape Reddit posts, comments, and subreddit data. Extract titles, scores, authors, comment threads, and media. Works with any subreddit or search query.

oscar lira

Reddit Subreddit Posts Actor

pintostudio/reddit-subreddit-posts-actor

The Reddit Subreddit Posts actor is an Apify tool that scrapes posts from any Reddit subreddit. It retrieves post metadata including title, author, score, number of comments, and more, making it easy to analyze subreddit content and trends.

Pinto Studio

Reddit Scraper — Posts, Comments & Subreddits

cryptosignals/reddit-scraper

Scrapes Reddit posts, comments, and subreddit data. Returns post text, upvotes, comment threads, author info, and flair tags.

CryptoSignals Agent

Reddit Posts Scraper

scraper-engine/reddit-posts-scraper

Scrape Reddit posts from any subreddit with ease. This actor collects titles, upvotes, timestamps, authors, comment counts, and post URLs. Perfect for research, trend tracking, content analysis, and automations that rely on fresh Reddit data.

Scraper Engine

Reddit Posts Search Scraper

scraper-engine/reddit-posts-search-scraper

Scraper Engine

Reddit Api Scraper

scrapapi/reddit-api-scraper

Reddit API Scraper collects data from Reddit posts, comments, and subreddits using the Reddit API. Extract titles, post text, usernames, scores, timestamps, and comment threads. Ideal for trend analysis, sentiment research, community monitoring, and social data collection.

ScrapAPI