The purpose-built Bright Data Reddit alternative

The response is JSON over HTTPS, so it drops into any language. Endpoint paths and parameters live in the API docs. Run the numbers for your volume with the cost calculator, or see the full per-endpoint rates on the pricing page.

Delivery model

Snapshot jobs or one request: how the data reaches you

The biggest practical difference between the two is not price, it is the shape of a request. Bright Data's Reddit scrapers are built around collection jobs. Per its Reddit scraper documentation, there are posts and comments scrapers; posts can be collected by URL or discovered by keyword or by subreddit URL, and discovery requests always run asynchronously. A synchronous request handles up to 20 URLs and waits up to one minute before handing back a snapshot id to collect later.

The asynchronous path, described in its async request guide, is a three-step loop: trigger a job and save the snapshot id, poll the snapshot until it reads ready (the guide says this takes 30 seconds to several minutes depending on the number of URLs), then download the results. Output comes as NDJSON by default, or JSON, JSON lines, CSV and Parquet, and can be delivered to a webhook or to storage such as Amazon S3. For a nightly batch of tens of thousands of URLs, that design is a real strength.

Redditapis works the other way round. Every call is an ordinary synchronous HTTPS request that answers with JSON in the same response: no job to trigger, no snapshot to poll, no file to fetch afterwards. That fits interactive tools, agents that need an answer inside one step, and pipelines that page through a listing as they go. If your workload is a large, scheduled, cross-site batch, the job model is a good fit. If it is many small Reddit questions answered in real time, a request per question is simpler to build and to debug.

Worked requests

Five Reddit jobs, and the exact call for each

Most Reddit data projects reduce to a handful of reads. These are the calls that replace a discovery job or a URL collection job, with the parameters each one actually accepts.

1. Find posts about a keyword in one subreddit

Post search takes q, an optional subreddit, sort (relevance, new, hot, top or comments, relevance when you leave it out) and a time window with t (hour, day, week, month, year or all). limit runs from 1 to 100 per call and defaults to 25. Leave subreddit out and the same call searches all of Reddit.

GET /api/reddit/search?q=scraping&subreddit=datascience&sort=new&t=week&limit=100

Post search also accepts filters Reddit itself does not offer, such as min_score, min_comments and is_self, plus sort_type (score, num_comments or created) to re-sort the page. They are applied to the page Reddit returned, so a strict filter can return fewer than limit rows; the response then carries a meta block with fetched, returned and filtered_out, so a small page is never mistaken for the end.

2. Read a subreddit's newest posts

The listing call is the counterpart of discovering posts by subreddit URL. sort takes new, hot, top, rising, controversial or best, and t narrows top and controversial to a window. The response also carries a before value, which walks toward newer posts, so a poller can ask for everything since its last run.

GET /api/reddit/posts?subreddit=datascience&sort=new&limit=100

3. Pull a whole comment thread

Where a comments collection job takes a post URL, here you pass the post id. One call returns the post plus up to 500 top-level comments with their replies (100 when you leave limit out), optionally cut to 1 to 10 levels with depth, in the sorts the Reddit site uses: confidence, top, new, controversial, old and qa. If you only kept the permalink, the same read takes permalink instead of an id.

GET /api/reddit/post/{postId}/comments?sort=top&limit=500&depth=10
GET /api/reddit/comments?permalink=/r/datascience/comments/{postId}/{slug}/

4. Follow every new comment in a community

The subreddit comment stream returns the newest comments across every thread in a community, up to 100 per call, paged with the after cursor. It is the cheapest way to watch a subreddit for mentions, because you read each comment once instead of re-reading whole threads.

GET /api/reddit/sub/datascience/comments?limit=100

5. Refresh posts you already stored

To update scores and comment counts on posts you saved earlier, send up to 100 post fullnames (the t3_ prefix plus the id), comma separated, in one call. An id Reddit no longer serves is left out of the posts rather than failing the batch, and named in meta.missing_fullnames so you know which rows to retire.

GET /api/reddit/by_id/t3_abc123,t3_def456,t3_ghi789

One note on comment search, because it trips up most first integrations. The comment search endpoint matches against comment text but returns the parent posts whose discussion matched, site-wide. When you need the matching comments themselves, deep comment search expands those parent threads (5 by default, up to 25 per call) and returns only the comments that contain your terms.

Paging and completeness

Pagination, the 1,000-item ceiling, and de-duplication

Every listing and search response carries an after value. Pass it back exactly as you received it to get the next page; it is an opaque cursor, so do not build or edit it yourself. When after comes back empty, the response adds a listing_status field that tells you why the listing stopped, with three possible values:

• complete: the evidence says the listing genuinely ran out, for example a short first page or a query with no hits.
• truncated: Reddit closed the listing at its own ceiling. Reddit stops serving any single listing at roughly 1,000 items, whoever is reading it, so older items exist that this listing will not return.
• unknown: Reddit stopped issuing a cursor and there is no evidence either way. Treat it as possibly partial.

Alongside it come items_returned, final_page_items and a plain hint, so you can check the verdict rather than trust a label. A comment thread is a tree, not a listing, so it reports truncated when Reddit left "load more" placeholders in the tree, and unknown otherwise.

The ceiling matters for planning. A truncated listing is not something to retry; it is a signal to split the question. Run the same search with a narrower t window, a different sort, or one subreddit at a time, and merge the results. Merged runs overlap, so de-duplicate on the post id (or the t3_ fullname in the name field) before you store anything, and keep the newest copy, since scores and comment counts move. For comments, the comment id is the key. A stream poller that keeps its last cursor and dedupes on id can run every few minutes without double-counting a single row.

Cost worked examples

What a Reddit workload costs, call by call

The unit here is the call, not the row. A read costs $0.0015 whether it returns 1 post or 100, so the cheapest way to read is a full page. Three typical workloads, priced at the published rates:

The $0.50 signup credit covers about 333 reads, enough to run each of these jobs on a small scale before you pay anything. Bright Data's Reddit scraper page describes its pricing as pay per successful record, so the comparable figure there is records delivered, not calls made. Price a sample of your real workload on both, at the same row count, and include the time your team spends on job orchestration on the scraper side.

Migration guide

Moving a Bright Data Reddit job to Redditapis

A Bright Data Reddit job is defined by its inputs, so the port starts there. Each input type has a direct counterpart:

• Discover posts by keyword becomes post search with q. A date input becomes the t window plus a created_utc filter in your own code, and a post count becomes limit plus paging.
• Discover posts by subreddit URL with a sort becomes the subreddit listing with the matching sort.
• Collect a post by URL becomes the post read by id, or by-id for up to 100 at a time.
• Collect comments by post URL becomes the comment-tree call. A days_back setting becomes a filter on each comment's created time on your side.

On the output side, the fields carry the same meaning under Reddit's own names: post_id becomes id, num_upvotes becomes upvotes, num_comments becomes comments, community_name becomes subreddit, and the posting date arrives as created_utc (epoch seconds) and created (an ISO timestamp). Map those once in your loader and the rest of the pipeline stays as it is.

A short cut-over checklist. First, replace the trigger, poll and download loop with direct calls, and drop the snapshot bookkeeping. Second, store the after cursor and the post id for every row you keep, so each run resumes where the last one stopped. Third, branch on listing_status: page on while after is set, accept complete, and split the query when you see truncated. Fourth, run both pipelines side by side for a few days on the same subreddits and compare row counts and timestamps. Fifth, when they agree on what they both cover, switch the old job off.

Five questions to settle before you choose

1. Is Reddit your only source, or one of many? A single platform for dozens of sites favours Bright Data; a Reddit-only product rarely needs that breadth.
2. Do you need answers inside a request, or files on a schedule? Agents and dashboards want a response now; a warehouse load is happy with a snapshot delivered to storage.
3. Will you ever post, comment, vote or send DMs? If so, a read collection tool will not cover it and a second integration becomes part of the plan.
4. How will you know a result is complete? Ask any provider what it returns when Reddit stops serving a listing, and whether that differs from a genuine end.
5. What is your unit of cost? Records delivered and calls made price the same job differently, so model your real volume at the same row count before comparing.

Frequently asked questions