Pricing

from $2.00 / 1,000 results

Reddit Scraper — Posts, Comments, Search & Users (Reliable)

Scrape Reddit posts, comment trees, search results, and user activity as clean JSON — engineered for reliability: rate-limit-aware pacing, host + proxy rotation, and per-target fault isolation. HTTP-only, no browser, no login.

Pricing

from $2.00 / 1,000 results

Rating

0.0

(0)

Developer

William Fordyce

Actor stats

Bookmarked

Total users

Monthly active users

a month ago

Last modified

Categories

Social media

Marketing

You can access the Reddit Scraper — Posts, Comments, Search & Users (Reliable) 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": "FWDVOqeRStHxZtud8"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/blubberstick~reddit-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-blubberstick-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/blubberstick~reddit-scraper/runs": {
      "post": {
        "operationId": "runs-sync-blubberstick-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/blubberstick~reddit-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-blubberstick-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",
        "properties": {
          "startUrls": {
            "title": "Start URLs",
            "type": "array",
            "description": "Any Reddit URLs — subreddit pages, individual posts, user profiles, or search-result pages. The type of each URL is detected automatically. Examples: <code>https://www.reddit.com/r/programming/top/?t=week</code>, <code>https://www.reddit.com/r/AskReddit/comments/abc123/some_post/</code>, <code>https://www.reddit.com/user/spez/</code>, <code>https://www.reddit.com/search/?q=apify</code>.",
            "items": {
              "type": "object",
              "required": [
                "url"
              ],
              "properties": {
                "url": {
                  "type": "string",
                  "title": "URL of a web page",
                  "format": "uri"
                }
              }
            }
          },
          "subreddits": {
            "title": "Subreddits",
            "uniqueItems": true,
            "type": "array",
            "description": "Subreddit names to scrape posts from, with or without the <code>r/</code> prefix — e.g. <code>programming</code> or <code>r/programming</code>.",
            "items": {
              "type": "string"
            }
          },
          "sort": {
            "title": "Sort posts by",
            "enum": [
              "hot",
              "new",
              "top",
              "rising"
            ],
            "type": "string",
            "description": "Which subreddit listing to scrape — same tabs you see on Reddit. <code>new</code> is best for monitoring, <code>top</code> for the most popular posts in a period.",
            "default": "new"
          },
          "topPeriod": {
            "title": "Top period",
            "enum": [
              "hour",
              "day",
              "week",
              "month",
              "year",
              "all"
            ],
            "type": "string",
            "description": "Time window for the <code>top</code> sort (ignored for other sorts).",
            "default": "week"
          },
          "searchQueries": {
            "title": "Search queries",
            "uniqueItems": true,
            "type": "array",
            "description": "Keywords or phrases to search Reddit for — e.g. your brand name, a product, a topic. Each query returns matching posts. Great for social listening and brand monitoring.",
            "items": {
              "type": "string"
            }
          },
          "searchSort": {
            "title": "Search sort",
            "enum": [
              "relevance",
              "hot",
              "top",
              "new",
              "comments"
            ],
            "type": "string",
            "description": "How to rank search results.",
            "default": "relevance"
          },
          "searchSubreddit": {
            "title": "Restrict search to subreddit",
            "type": "string",
            "description": "Optional: limit all search queries to a single subreddit, e.g. <code>smallbusiness</code>. Leave empty to search all of Reddit.",
            "default": ""
          },
          "users": {
            "title": "Users",
            "uniqueItems": true,
            "type": "array",
            "description": "Reddit usernames to scrape, with or without the <code>u/</code> prefix — e.g. <code>spez</code>.",
            "items": {
              "type": "string"
            }
          },
          "userDataType": {
            "title": "User data to fetch",
            "enum": [
              "posts",
              "comments",
              "both"
            ],
            "type": "string",
            "description": "Whether to scrape each user's submitted posts, their comments, or both.",
            "default": "posts"
          },
          "includeComments": {
            "title": "Include comments",
            "type": "boolean",
            "description": "For every scraped post, also fetch and flatten its comment tree (one dataset item per comment, with <code>postId</code>, <code>parentId</code>, and <code>depth</code> for re-assembly). Adds one extra request per post.",
            "default": false
          },
          "maxItems": {
            "title": "Max items",
            "minimum": 1,
            "type": "integer",
            "description": "Maximum number of posts / user items scraped across all sources combined — the budget is split fairly across your subreddits, queries, users, and URLs. Comments fetched via <b>Include comments</b> are controlled separately by <b>Max comments per post</b>.",
            "default": 100
          },
          "maxCommentsPerPost": {
            "title": "Max comments per post",
            "minimum": 1,
            "type": "integer",
            "description": "Cap on comments scraped per post when <b>Include comments</b> is on. Deeply nested \"load more comments\" stubs are skipped and their count is reported on the post item as <code>moreCommentsSkipped</code>.",
            "default": 50
          },
          "proxyConfiguration": {
            "title": "Proxy configuration",
            "type": "object",
            "description": "Proxies to use. Residential proxies (default) are strongly recommended — Reddit aggressively blocks datacenter IP ranges. The actor automatically rotates to a fresh proxy session whenever Reddit rate-limits or blocks a request.",
            "default": {
              "useApifyProxy": true,
              "apifyProxyGroups": [
                "RESIDENTIAL"
              ]
            }
          }
        }
      },
      "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 � posts, comments, search, users (no login) 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 — Posts, Comments, Search & Users (Reliable) 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 — Posts, Comments, Search & Users (Reliable) API in Python

Reddit Scraper — Posts, Comments, Search & Users (Reliable) API in JavaScript

Reddit Scraper — Posts, Comments, Search & Users (Reliable) API through CLI

Reddit Scraper — Posts, Comments, Search & Users (Reliable) API

Reddit Posts + Comments Scraper

softwaresubs29/reddit-posts-comments-scraper

Scrapes Reddit posts and complete comment trees (including 'load more' branches) from subreddits, posts, user profiles, or keyword search. HTTP-only — no browser — for low compute cost.

Shab Codes

👽 Reddit Scraper — Posts, Comments & Search

inexhaustible_glass/reddit-scraper

Scrape Reddit posts, comments, search results & user activity. No login, no API key. Subreddit hot/new/top/rising, keyword search, full comment trees. Auto-paginated. For market research, lead monitoring, brand sentiment & content ideas.

Hitman studio

Reddit Scraper

labrat011/reddit-scraper

Scrape Reddit posts, comments, search results, and user profiles. No API keys or browser needed. Supports 4 modes: subreddit posts (hot/new/top/rising), Reddit search, user profiles, and full comment trees. Fast, lightweight HTTP-based scraping with built-in rate limiting and retry logic.

mick_

162

Reddit Search Scraper — Posts, Comments & Users

logiover/reddit-search-scraper

Scrape Reddit subreddit search with no API key or login. Export posts and comments to CSV/JSON — a Reddit API alternative for keyword monitoring.

Logiover

Reddit Scraper — Posts, Comments, Users, Subreddits

good-apis/reddit-scraper

Fast Reddit scraper. Search posts, get subreddit data, user profiles, and comments. No login, no browser, clean JSON output. Launch pricing: $1.25 / 1,000 results.