The official Reddit Data API vs Redditapis

Redditapis documents 74 REST endpoints per the Redditapis OpenAPI spec at docs.redditapis.com/openapi.json, spanning read, search, vote, write, and DM over one surface. Estimate your own number against these rates with the cost calculator.

The response is JSON over HTTPS, so it drops into any language. Full endpoint paths and parameters live in the API docs.

Before the first read

What the official API asks of your client

Approval is the slow part, but it is not the only work. Reddit's Data API Wiki sets out a short list of rules every client has to follow, and each one is a piece of code you write and maintain:

• A registered OAuth token. Clients must authenticate with one, and traffic that uses neither OAuth nor login credentials is blocked. Reddit's OAuth2 guide adds that bearer tokens expire after one hour and that requests made with one go to oauth.reddit.com, so your client also owns a token refresh loop.
• A unique User-Agent. The wiki asks for the format platform, app id, version string and your Reddit username, and warns that default agents such as Python/urllib are drastically limited.
• Rate-limit bookkeeping. The free limit is 100 queries per minute per OAuth client id, averaged over a 10-minute window so short bursts are allowed. Your client reads X-Ratelimit-Used, X-Ratelimit-Remaining and X-Ratelimit-Reset on every response and slows down before it runs out.
• Deletion handling. Content deleted on Reddit must be removed from your copy too, and the wiki recommends routinely deleting stored user data and content within 48 hours.

With Redditapis the first three collapse into one header: your API key as a bearer token on a plain HTTPS request, with no token exchange, no User-Agent policy to satisfy and no per-minute quota on Reddit data calls to track. The fourth is about the data rather than the pipe. If you store Reddit content, plan a retention job whichever path you choose; the by-id call below makes the re-check cheap, since it reports every id Reddit no longer serves.

Worked requests

The same search, written both ways

Searching r/python for posts about async, newest first, is a good small test. On the official API it is two requests and a header you must get right:

# 1. exchange your app credentials for a token (valid one hour)
POST https://www.reddit.com/api/v1/access_token
     grant_type=client_credentials
# 2. search with the token and a descriptive User-Agent
GET  https://oauth.reddit.com/r/python/search?q=async&restrict_sr=on&sort=new&limit=100
     Authorization: Bearer <token>
     User-Agent: <platform>:<app id>:<version> (by /u/<username>)

On Redditapis it is one request. You pass subreddit as a plain parameter rather than a path plus restrict_sr, and the response comes back as flat post objects (id, title, author, subreddit, upvotes, comments, created_utc and more) instead of Reddit's nested listing envelope:

GET https://api.redditapis.com/api/reddit/search?subreddit=python&q=async&sort=new&limit=100
    Authorization: Bearer YOUR_API_KEY

The parameters are Reddit's own vocabulary, validated before the call goes upstream: sort is relevance, new, hot, top or comments; t is hour, day, week, month, year or all; limit is 1 to 100 and defaults to 25. A misspelled value comes back as a 400 that names the allowed values, instead of being silently ignored and billed. Three more reads cover most of what a direct integration does:

GET /api/reddit/posts?subreddit=python&sort=new&limit=100        # a subreddit listing
GET /api/reddit/post/{postId}/comments?sort=top&limit=500&depth=10  # a whole thread
GET /api/reddit/by_id/t3_abc123,t3_def456                           # up to 100 stored posts

Paging and completeness

Same 1,000-item ceiling, reported differently

Both paths read the same Reddit listings, so both meet the same limit: Reddit stops serving any single listing at roughly 1,000 items and then stops issuing an after token. On a direct integration that ending looks exactly like reaching the end of a small subreddit, an empty after on a short page. Telling the two apart is left to you.

Redditapis issues its own opaque after cursor that carries how deep you have paged, and when the cursor runs out the response says why in listing_status. complete means the evidence points to a genuine end, such as a short first page or a query with no hits. truncated means Reddit closed the listing at its ceiling, so older items exist that this listing will not return. unknown means Reddit stopped and there is no evidence either way. items_returned, final_page_items and a plain hint ride along so you can check the verdict yourself.

Comment threads work the same way on both paths, because they are trees rather than pages. Reddit leaves "load more" links where it stopped expanding a branch. Here a thread read takes up to 500 top-level comments and a depth of 1 to 10, and reports truncated when such a link is present. When a listing comes back truncated, the fix is the same on either side: split the question with a narrower t window, another sort or one subreddit at a time, merge the runs, and de-duplicate on the post or comment id before storing.

Cost worked examples

The monthly bill at three volumes

Both prices are per call, so the arithmetic is simple. Reddit's reported commercial rate works out to $0.24 per 1,000 calls; Redditapis reads are $0.0015 each. Here is what that means for a month of reads:

Read honestly, the table says the official rate is the cheaper per call at every volume, which is why this page has never claimed otherwise. What it leaves out is everything before the first billed call: the app review, the agreement, the token, User-Agent and rate-limit code, and the weeks in between. The free tier does not change the comparison for a business, because it prohibits commercial use; for a personal project it is the right choice, and at 100 queries a minute it allows up to 4,320,000 calls in a 30-day month if every minute were used. On Redditapis the $0.50 signup credit covers about 333 reads, enough to prove a workload before you pay.

Decision checklist

Questions to answer before you pick a path

1. Is the use commercial? If yes, the official path runs through an application and an agreement, and the free tier is not an option.
2. When do you need production data? A launch date inside the likely review window favours starting on a hosted API and revisiting later.
3. How many Reddit features are on the roadmap? One fixed integration suits going direct; a growing list means a standing relationship with a review process.
4. Who maintains the client? Token refresh, User-Agent policy and rate-limit headers are small jobs that break at inconvenient times.
5. At what monthly volume does the per-call difference outweigh the setup and maintenance? Use the three volumes above as a starting point.

If you are moving an existing direct integration across, the port is short. Replace the token exchange and the oauth.reddit.com host with the Redditapis base URL and your key. Swap path-based subreddit search for the subreddit parameter, and drop restrict_sr. Map the listing envelope to the flat post fields, noting that score arrives as upvotes and num_comments as comments. Store our after cursor exactly as returned, and branch on listing_status instead of guessing from page size. Then run both clients side by side on the same subreddits for a few days and compare row counts before switching the old one off. The reverse move is just as open: nothing here locks you in, and the official API is always there once approval and volume make it the better deal.

Frequently asked questions