The maintained Pushshift alternative

The short answer

If you need historical and live Reddit data today, reach for a maintained REST API rather than a free Pushshift mirror. PullPush and Arctic Shift still run, but they are volunteer projects with no SLA, hard rate limits, and gaps under load, so they suit one-off research rather than a production pipeline. Redditapis covers the same search of posts, comments, and users over plain HTTPS, needs no Reddit app approval, and bills a flat $0.0015 per read, so the cost tracks your volume instead of a contract.

Coverage and rate limits, source by source.

Which should you use?

Pick by the job in front of you, not by which option is free. A static academic dump fits a one-time research corpus where weeks of staleness is fine and you can process gigabytes locally. A community mirror such as PullPush fits a hobby query you can retry when it times out. A maintained REST API fits anything you have to depend on: live and recent data, a predictable rate limit, and a bill you can plan around to the call.

• A historical corpus you process offline, at no cost. Academic dumps or Arctic Shift torrents, accepting weeks of lag.
• Occasional lookups with no uptime requirement. PullPush, with retry logic for the timeouts and rate-limit walls.
• A production data path for live plus recent data at a predictable cost. A maintained REST API like Redditapis, billed per call from $0.0015.

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.

Migration guide

Pushshift parameters, mapped to Redditapis calls

Most Pushshift code leaned on a handful of query parameters: ids, subreddit, sort, sort_type and size. Each one has a direct counterpart here, but a few behave differently, and those differences are where a port breaks quietly. This section walks through the four lookups that cover nearly every Pushshift script, with the exact call that replaces each.

Getting comments based on id

Pushshift let you pass a list of comment ids and get those comments back. Reddit itself organises comments under the post they belong to, so the dependable way to read them is by the post: request the post's comment tree by its id and the thread comes back in one response: up to 500 comments, each with its replies, optionally cut to 1 to 10 levels with depth, in the same sort orders the Reddit site uses (confidence, top, new, controversial, old and qa).

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

If you stored post ids rather than comment ids, hydrate up to 100 posts in a single call with their t3_ fullnames, comma separated. An unknown id is left out of the result instead of failing the whole request, so a batch with a few deleted posts still returns the rest.

GET /api/reddit/by_id/t3_abc123,t3_def456
GET /api/reddit/comment/t1_ghi789

A stored t1_ comment id still reads back on its own: fetch it with the single-comment endpoint, one call per comment. When you need many comments from the same thread, one comment-tree call per post is usually far fewer calls than one per comment, so store the parent post id beside each comment id and choose per job.

Using the subreddit parameter

On Pushshift, subreddit filtered any search. Here it filters post search: pass subreddit with your query and results stay inside that community. Comment search works across all of Reddit and returns the posts whose discussion matches, so a subreddit value on that endpoint is not applied. To read a community's comments as they arrive, use its comment stream instead, paged with the after cursor.

GET /api/reddit/search?subreddit=python&q=async&sort=new&limit=100
GET /api/reddit/sub/python/comments?limit=100

The practical rule for a port: keep subreddit on post searches, and move any per-community comment collection to the stream. Filtering a site-wide comment search afterwards by subreddit works too, but you pay for the rows you throw away.

Using the sort and size parameters

Pushshift's size set how many rows came back, and sort with sort_type ordered them by score, comment count or creation time. Here the row count is limit, from 1 to 100 per call (25 if you leave it out), and you page beyond 100 by passing back the after value from the previous response exactly as you received it. When after comes back empty, check listing_status: it tells the true end of the listing apart from Reddit's own cap of about 1,000 items.

Post search takes Reddit's own orders (relevance, new, hot, top and comments) plus a time window with t (hour, day, week, month, year or all). If your script depended on Pushshift's sort_type, the same name is accepted on post search: score, num_comments or created re-sorts each returned page in descending order, which keeps most ported loops working without edits.

GET /api/reddit/search?q=rust&subreddit=programming&sort=top&t=month&limit=100&sort_type=num_comments

One difference to plan for: sort_type orders the page you received, not the whole result set, so a top-100 by comment count across a month means paging through the window and ranking the rows you collected. Each page is one billed call, which makes the cost of a backfill easy to estimate before you run it.

Replacing the after and before date filters

Pushshift took epoch timestamps in after and before, so a script could ask for exactly one week in 2021. Live Reddit search does not take an arbitrary date range. It takes a time window with t (hour, day, week, month, year or all) and returns results inside it, newest or most relevant first. Note that after means something different here: it is the paging cursor from the previous response, not a timestamp, so a ported script must stop writing dates into it.

For recent windows, which is what most monitoring and research jobs actually read, the window covers it: t=day or t=week with sort=new, paged until the created_utc of the rows passes your cut-off, then stop. Every row carries created_utc, so trimming to an exact start and end time happens on your side in one line of code. For a fixed window years in the past, an archive dump is still the right tool, and the comparison above says where each one fits.

GET /api/reddit/search?q=llm&subreddit=MachineLearning&sort=new&t=week&limit=100
# keep paging with after=<cursor> until created_utc < your start time

Fields that carry over, and the ones that change

Most fields Pushshift code read keep their names and units on each post: id, author, subreddit, title, permalink and created_utc. Two are renamed: score is upvotes and num_comments is comments, so a ported parser maps those two and leaves the rest alone. (score and num_comments stay valid as sort_type values on post search.) Ids follow Reddit's own convention, a short id plus a t3_ prefix for the fullname when an endpoint asks for one, which is what the bulk by-id call expects.

The difference is freshness. Pushshift stored a snapshot taken when it first ingested a post, so score and comment counts were frozen early and edits or removals often never showed up. Here every read is current at the moment of the call: scores move, and deleted or removed content shows Reddit's own [deleted] and [removed] markers. If your analysis depended on the original text of later-deleted posts, keep your own copy at read time; if it depended on accurate counts, the live values are the better source.

What a ported script usually looks like

A typical Pushshift job polled a subreddit for new comments, pulled matching posts for a keyword, and occasionally re-read a thread to capture late replies. On this API that becomes three calls in a loop: the subreddit comment stream for new comments, post search with subreddit and sort=new for keyword matches, and the comment tree by post id for the re-read. Keep the last after cursor between runs so each poll starts where the previous one stopped, and store post ids with every comment so a later re-read never has to search again.

A short checklist before you switch the old job off. First, replace the base URL and add the Authorization header with your key; nothing else about the HTTP call changes. Second, rename size to limit and cap it at 100, and turn any after or before timestamps into a t window plus a created_utc filter in your own code. Third, move per-subreddit comment collection from search to the subreddit comment stream. Fourth, store the after cursor and the post id for every row you keep. Fifth, run the new job beside the old one for a day and compare row counts for the same subreddit and keyword: the live counts will be a little higher, because Pushshift often missed late comments and edits. When the two agree on what they both cover, the old job can go.

Frequently asked questions