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

Legacy Unauthenticated Requests (JSON Endpoints)

The old unauthenticated limits below are historical. Beginning May 30, 2026, Reddit broadly blocked .json URLs, and these requests now usually return 403 Forbidden instead of reaching a usable rate-limit window:

  • 10 requests per minute — the former hard limit before the shutdown
  • 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

ScenarioWhat Reddit Returns
OAuth, over rate limit429 Too Many Requests + X-Ratelimit-Reset header
Legacy unauthenticated JSON requestUsually 403 Forbidden since May 30, 2026
JSON endpoint, over limit429 or HTML captcha page (no JSON)
JSON endpoint, suspected botHTML login page with 200 OK status (looks like success but isn’t)
Any endpoint, Reddit under load503 Service Unavailable or empty response

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.


Rate limits in a React app

A browser app should never call a rate-limited API directly with your key: anything in the bundle is public, and every visitor would share one quota. Put one small route on your server, keep the key there, and do the retrying there.

The retry helper honours Retry-After when the API sends it (seconds or an HTTP date) and otherwise backs off exponentially with a little jitter, retrying 429s and 5xx responses only:

// Server-side only: retries 429s and 5xx responses, waiting for Retry-After
// when the API sends it, otherwise backing off exponentially with jitter.
export async function fetchWithBackoff(url: string, init: RequestInit = {}, maxAttempts = 5): Promise<Response> {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(url, init);
    const retryable = res.status === 429 || res.status >= 500;
    if (!retryable || attempt === maxAttempts) return res;

    const header = res.headers.get('retry-after');
    let waitMs = 1000 * 2 ** (attempt - 1) + Math.random() * 250; // 1s, 2s, 4s, 8s…
    if (header) {
      const seconds = Number(header);
      waitMs = Number.isFinite(seconds) ? seconds * 1000 : Math.max(0, Date.parse(header) - Date.now());
    }
    await new Promise((resolve) => setTimeout(resolve, waitMs));
  }
}

Against a local test server that answered 429 with Retry-After: 1 twice, it waited 1,001 ms each time and returned the third response, a 200. With no header, the waits were 1 and then 2 seconds.

The server route the React app calls, here using our Reddit search endpoint (any rate-limited API works the same way):

import { fetchWithBackoff } from './fetchWithBackoff';

// The React app calls this route; the API key never leaves the server.
Bun.serve({
  port: 3001,
  routes: {
    '/api/search': async (req) => {
      const q = new URL(req.url).searchParams.get('q') ?? '';
      const res = await fetchWithBackoff('https://api.fetchlayer.dev/reddit/search', {
        method: 'POST',
        headers: { Authorization: `Bearer ${process.env.FETCHLAYER_API_KEY}`, 'Content-Type': 'application/json' },
        body: JSON.stringify({ query: q }),
      });
      return new Response(res.body, { status: res.status, headers: { 'Content-Type': 'application/json' } });
    },
  },
});

And the component, which only ever talks to your own route:

import { useEffect, useState } from 'react';

export function SearchResults({ query }: { query: string }) {
  const [posts, setPosts] = useState<{ id: string; title: string }[]>([]);
  const [error, setError] = useState('');

  useEffect(() => {
    // Your own route, not the API: no key in the browser, and retries happen server-side
    fetch(`/api/search?q=${encodeURIComponent(query)}`)
      .then(async (res) => {
        const data = await res.json();
        if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
        setPosts(data.items);
      })
      .catch((e: Error) => setError(e.message));
  }, [query]);

  if (error) return <p>Search failed: {error}</p>;
  return <ul>{posts.map((p) => <li key={p.id}>{p.title}</li>)}</ul>;
}

We ran the route against the live API on 14 November 2026: /api/search?q=rate%20limit returned 7 posts in one call. If many users search at once, cap concurrency on the server too, so a burst of visitors doesn’t turn into a burst of 429s.

Rate limits in Airflow

In an Airflow DAG you don’t need a retry loop in the task. Let the task fail on a 429, and let Airflow retry it with backoff. From the Airflow 3 documentation (Task SDK 1.4.0 and Airflow 3.4.0, read on 14 November 2026):

  • retries is “the number of retries that should be performed before failing the task”.
  • retry_exponential_backoff is a “multiplier for exponential backoff between retries. Set to 0 to disable (constant delay). Set to 2.0 for standard exponential backoff (delay doubles with each retry).”
  • max_retry_delay is the “maximum delay interval between retries”.
  • Pools “can be used to limit the execution parallelism on arbitrary sets of tasks”, and “once capacity is reached, runnable tasks get queued”.

The pool is what stops a mapped task, or several DAGs, from hitting the same API in parallel. Create one under Admin → Pools with as many slots as you want calls in flight (two is a safe start), then point the task at it:

import os
from datetime import datetime, timedelta

import requests
from airflow.sdk import dag, task

QUERIES = ["rate limit", "api pricing", "data export"]


@dag(schedule="@daily", start_date=datetime(2026, 11, 1), catchup=False)
def reddit_search():
    @task(
        retries=5,
        retry_delay=timedelta(seconds=30),
        retry_exponential_backoff=2.0,  # 30s, 60s, 120s… (Airflow 3 docs)
        max_retry_delay=timedelta(minutes=10),
        pool="search_api",  # caps how many of these run at once
    )
    def search(query: str) -> int:
        res = requests.post(
            "https://api.fetchlayer.dev/reddit/search",
            json={"query": query},
            headers={"Authorization": f"Bearer {os.environ['FETCHLAYER_API_KEY']}"},
            timeout=120,
        )
        res.raise_for_status()  # a 429 or 5xx fails this try, and Airflow retries it
        return len(res.json()["items"])

    search.expand(query=QUERIES)


reddit_search()

We loaded this DAG with the Airflow Task SDK (1.4.0) and checked the task carries the settings: 5 retries, a 30-second first delay doubling up to 10 minutes, and the search_api pool, taking 1 slot per running task. Without a pool, Airflow puts tasks in default_pool, which its docs say “is initialized with 128 slots”, far more parallel calls than most APIs allow.

Sources: BaseOperator parameters · Pools


The Alternative: Skip Rate Limits Entirely

Rate limits are a constraint of Reddit’s official API. A scraping API like FetchLayer takes care of rate limits for you. You make a request, you get JSON back.

// No rate limit headers to track. No 429s to handle.
const res = await fetch('https://api.fetchlayer.dev/reddit/search', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ss-your-fetchlayer-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

Access MethodRate LimitBurst BehaviorCommercial Use
Legacy JSON endpoints (no auth)Broadly blocked (usually 403)N/ANo
OAuth (free tier)100 req/minThrottled on burstNo
OAuth (enterprise)NegotiatedNegotiatedYes (price not published)
Scraping API (e.g., FetchLayer)Handled by providerNo client-side throttlingYes (free tier available)

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.