Reddit API Rate Limits Explained (and How to Avoid Them)

If you’ve used Reddit’s API for more than a few minutes, you’ve probably hit a 429 error. Reddit rate-limits aggressively, and the limits vary depending on how you’re authenticated, which endpoint you’re calling, and whether Reddit feels like enforcing stricter rules that day.

Here’s a clear, no-BS breakdown of how Reddit’s rate limiting actually works in 2026.

The Official Rate Limits

Unauthenticated Requests (JSON Endpoints)

If you’re hitting Reddit’s .json URLs without OAuth:

• 10 requests per minute — hard limit
• No warning headers — you just get a 429 Too Many Requests or an HTML captcha page
• Reddit may serve you a login page instead of JSON with zero indication in the status code
• These endpoints are for personal/experimental use only

OAuth-Authenticated Requests

If you’ve registered a Reddit app and are using OAuth tokens:

• 100 requests per minute — the standard rate
• Reddit sends X-Ratelimit-Used, X-Ratelimit-Remaining, and X-Ratelimit-Reset headers
• Some endpoints have stricter per-endpoint limits on top of the global rate:
  • Comment submission: 1 per 10 seconds
  • Post submission: 1 per 10 minutes (for new accounts)
  • /api/morechildren: 1 request per 2 seconds
  • Search: lower effective throughput due to processing time

Burst Limits

Even within the 100/min window, Reddit may throttle bursts. Sending 50 requests in 1 second and then nothing for the rest of the minute can trigger temporary blocks. Reddit prefers evenly spaced requests.

What Happens When You Hit the Limit

The last two are the worst — your code thinks it got a valid response, but the body is HTML garbage. Always check that the response body is actually JSON before parsing.

Common Mistakes That Trigger Rate Limits

1. Not Handling "more" Stubs Efficiently

When you fetch a post’s comments, Reddit returns a partial tree with "more" stubs. Expanding each stub requires a separate /api/morechildren call. A 500-comment thread can require 10+ calls just for comments — and each one counts against your rate limit.

2. Polling Too Frequently

Checking a subreddit for new posts every 30 seconds burns 2 req/min per subreddit. Monitor 10 subreddits? That’s 20 req/min just on polling — one-fifth of your quota before you’ve done anything useful.

3. Not Respecting the Headers

Reddit tells you exactly when your rate limit resets via the X-Ratelimit-Reset header. If you ignore it and keep hammering, you’ll get 429s and potentially a temporary IP ban.

4. Running Parallel Requests

Launching 20 concurrent requests from the same token will exceed the burst threshold even if you’re under 100/min on average.

How to Handle Rate Limits in Code

Basic Rate-Limit-Aware Client (Node.js)

class RedditClient {
  constructor(accessToken) {
    this.token = accessToken;
    this.remaining = 100;
    this.resetAt = Date.now();
  }

  async request(endpoint) {
    // Wait if we're out of budget
    if (this.remaining <= 1 && Date.now() < this.resetAt) {
      const waitMs = this.resetAt - Date.now() + 100;
      await new Promise(r => setTimeout(r, waitMs));
    }

    const res = await fetch(`https://oauth.reddit.com${endpoint}`, {
      headers: {
        'Authorization': `Bearer ${this.token}`,
        'User-Agent': 'MyApp/1.0'
      }
    });

    // Update rate limit tracking
    this.remaining = parseInt(res.headers.get('x-ratelimit-remaining') || '100');
    const resetSeconds = parseFloat(res.headers.get('x-ratelimit-reset') || '60');
    this.resetAt = Date.now() + (resetSeconds * 1000);

    if (res.status === 429) {
      // Back off and retry
      await new Promise(r => setTimeout(r, resetSeconds * 1000 + 500));
      return this.request(endpoint);
    }

    return res.json();
  }
}

This works, but you’re spending significant engineering time on infrastructure that has nothing to do with your actual product.

The Alternative: Skip Rate Limits Entirely

Rate limits are a constraint of Reddit’s official API. A scraping API like FetchLayer handles rate limiting, proxy rotation, and retry logic on the backend. You make a request, you get JSON back.

// No rate limit headers to track. No 429s to handle.
const res = await fetch('https://fetchlayer.dev/api/reddit/search', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-your-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ query: 'best CRM', sort: 'top' })
});

const data = await res.json();

No OAuth setup, no token refresh, no burst throttling, no X-Ratelimit-* header parsing. The rate limiting complexity is FetchLayer’s problem, not yours.

Rate Limit Summary

Frequently Asked Questions

I’m getting 429 errors even under 100 req/min. Why?

Reddit enforces per-endpoint limits on top of the global rate. /api/morechildren is limited to 1 req/2 seconds. Search can be slower. Also, burst detection may trigger before you hit the per-minute cap.

Can I increase the rate limit?

On Reddit’s free tier, no. You can apply for “approved app” status, but approval is not guaranteed and the increase is modest. For serious throughput, Reddit requires an enterprise agreement.

Do scraping APIs have rate limits?

Yes, but they’re higher and managed server-side. You don’t need to implement retry logic — the API returns data or a clear error. FetchLayer’s rate limits are plan-based, not per-minute Reddit quotas.

Related Guides

• How to Scrape Reddit in 2026
• How to Get All Comments from a Reddit Post
• Reddit API Alternatives
• PRAW Alternative for JavaScript