Twitter rate limit exceeded: how to fix it

#What "rate limit exceeded" means on X

"Rate limit exceeded" is X telling you that you crossed a cap. A rate limit is a cap on how many times an account, an app or a program may do one thing in a set window, and X keeps one for reading, posting, following, messaging and every endpoint of its API.

Which cap you hit depends on where the message appeared. In the X app or on x.com, it is a limit on your own account. In a connected tool or a reader site such as xcancel, it is that tool's access to X. In your own code it arrives as HTTP 429, and the guide to X API error codes explains the whole response, reset time included.

X says its limits take strain off its systems and cut downtime, and that they may be lowered for everyone during periods of heavy site usage. The same habits can pass on a quiet day and trip a limit on a busy one.

#How long a Twitter rate limit lasts

Most rate limits on X last between 15 minutes and one day, and the wait depends on which cap you hit: each one runs on its own clock. The official X API's endpoint windows reset within 15 minutes on most endpoints; account caps on posts take a few hours, and those on messages and follows take a day.

• Posts and replies come back within a few hours: X counts the daily cap in semi-hourly slices and asks you to try again a few hours later.
• Direct messages and follows come back when the day's limit has passed.
• Third-party apps share an hourly limit, so they work again within the hour.
• Official X API windows reopen at the Unix time in the x-rate-limit-reset header: 15 minutes on most endpoints, 24 hours on a few.
• The reading limit has no published duration at all.

The reading limit is the one most people meet while scrolling, and the only one X has never put on its limits page (opens in a new tab). In July 2023 X capped reading at 6,000 posts a day for verified accounts, 600 for unverified and 300 for new ones, and called the caps temporary, as Reuters reported (opens in a new tab). No current figure has been published since, so a page that quotes one is guessing.

Good to know

X's limits page lists 50 posts and 200 replies a day for unverified accounts, yet a paragraph further down still mentions 2,400 updates a day. The list is the current rule: X cut the cap in May 2026, as reported by PCMag (opens in a new tab). Guides that quote 2,400 copy the stale line.

#How to fix "rate limit exceeded" in the X app

To fix "rate limit exceeded" in the X app or on x.com, stop the action that tripped it, close X and wait out the time above. Nothing on your side resets an account cap sooner.

1. Stop refreshing. Each reload asks X for more posts and counts against the same limit.

2. Find the action. Scrolling, posting, following and messaging each have their own cap; the decoder above gives the wait for each.

3. Disconnect apps you don't use. In Settings and privacy, open Security and account access, then Apps and sessions, and revoke the tools you no longer need: they all share one hourly API limit.

4. Check whether it's everyone. X lowers limits for all accounts when the site is under heavy load and posts an update on its status site. If friends see the same message, the wait is X's.

5. Try once. After the wait, do one action and see that it goes through before you carry on.

Logging out and back in, switching to another browser or device, or moving to a different network does not reset an account cap. X counts account actions from every device and from the API alike, so a fresh session meets the same counter.

#How to fix an X API 429 error in your code

A 429 from the official X API means one of two limits, and only one of them clears in minutes, so read the error type before you sleep. X's error reference (opens in a new tab) lists both behind the same status: a rate limit or a usage cap.

The window limit is the common one. Every endpoint allows a set number of requests per 15 minutes, or per 24 hours on a few, counted per app with a Bearer token and per user with OAuth tokens. Three headers on every response show where you stand: x-rate-limit-limit, x-rate-limit-remaining and x-rate-limit-reset, a Unix time in seconds. Once remaining hits 0, every call returns 429 with error code 88 until that time. The numbers per endpoint are in our guide to X API rate limits.

The usage cap is monthly. Pay-per-use access stops at 3M post reads per billing cycle, and past it every read returns 429 with the type usage-capped until the cycle ends or you move to an Enterprise contract, so retrying at the reset time only burns attempts. A spending limit set in the Developer Console blocks requests the same way until the next cycle, and a credit balance at zero blocks them until you add credits.

This handler sleeps until the reset for a window limit and stops for a usage cap:

import time
import requests

def get_x(url, headers, params=None):
    while True:
        r = requests.get(url, headers=headers, params=params, timeout=30)
        if r.status_code != 429:
            r.raise_for_status()
            return r.json()
        if "usage-capped" in r.text:
            raise RuntimeError("X usage cap: wait for the next billing cycle")
        reset = int(r.headers.get("x-rate-limit-reset", time.time() + 60))
        time.sleep(max(reset - time.time(), 1) + 1)

Spreading calls across the window keeps the next 429 away: recent search allows an app 450 requests per 15 minutes, so one request every 2 seconds never reaches the limit. If the message says your request looks automated, it is not a rate limit at all; that error has its own causes, covered in why X says a request looks automated.

#Rate limited when you did almost nothing

You can be rate limited after a handful of actions because the count includes more than your own taps: apps working in the background, shared services and X's lower limits on busy days.

• Connected apps. A scheduler, an analytics tool and a follower tracker all draw on one hourly API limit for your account, so together they can use it up while you sleep.
• Shared readers. xcancel and Nitter instances read X on behalf of every visitor. When one hits X's limits, everyone who opens it sees "rate limited", and your own account plays no part.
• Embedded timelines. An X timeline embedded on a website loads through X's embed service, which can answer the site with a 429 of its own.
• Busy days. X may lower limits for everyone during heavy use, so a normal session can trip a limit that would pass on another day.

If none of these fits and your posts simply stopped reaching people without any message, the cause is not a rate limit: see the FAQ on shadowbans below.

#Read X data at 20 requests per second with Sorsa API

For reading public X data from code, Sorsa API, a Twitter (X) API and scraper, has one limit instead of per-endpoint windows: 20 requests per second per API key (opens in a new tab), on every plan. A 429 there means more than 20 calls landed in one second, and the next second works again.

It needs one API key in an ApiKey header, no X developer account and no OAuth, and it never asks for your X login, so your X account is never at risk; our guide to the Twitter API without a developer account walks through that setup. Sorsa API reads public data only and never posts; to publish, pair it with the official X API.

Side by side, Sorsa API resets every second and carries no 3M-read ceiling, while the official X API resets per endpoint and stops at 3M post reads a month:

• Rate limit

  Sorsa API

  20 requests per second per key, every plan

  Official X API

  Per endpoint, per app and per user, mostly per 15 minutes

• A 429 means

  Sorsa API

  Over 20 requests in one second

  Official X API

  A window ran out, or the usage cap was reached

• Retry after

  Sorsa API

  The next second

  Official X API

  x-rate-limit-reset, or the next billing cycle

• Monthly ceiling

  Sorsa API

  Your plan's requests, with extra requests on top

  Official X API

  3M post reads, then Enterprise from about $42K a month

• Price per 1,000 posts

  Sorsa API

  From $0.014 by ID, from $0.07 by search

  Official X API

  $5.00

• Access

  Sorsa API

  One API key

  Official X API

  Developer account and OAuth

From November 22, 2026, the official X API also bills the author that comes with each post at $0.010 per user (X's notice (opens in a new tab)), while every Sorsa API tweet carries its full author profile in the same request. The rest of X's price list is in our X API pricing breakdown.

1. Get a key. Sign up and copy your API key from the dashboard. The first 100 requests are free.

2. Search in one request. POST /search-tweets (opens in a new tab) takes any X search query and returns about 20 posts per page, with a next_cursor for the next page.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "from:ratelimit_fix_demo", "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "2117203385470271488",
         "full_text": "Paced reads, no 15-minute windows.",
         "created_at": "2026-11-02T10:41:07Z",
         "lang": "en",
         "likes_count": 12,
         "retweet_count": 3,
         "reply_count": 1,
         "view_count": 1840,
         "user": {
           "id": "1592041833471827968",
           "username": "ratelimit_fix_demo",
           "display_name": "Rate Limit Demo",
           "followers_count": 920
         }
       }
     ],
     "next_cursor": "DAACCgACG1x7rWyAJxAKAAMbXHutbH_YUwgABAAAAAEAAA"
   }
   

   Show full response

3. Page at full speed. Send next_cursor back until it comes back empty, pause a twentieth of a second between calls, and treat a 429 as a one-second wait.

   import time
   import requests
   
   URL = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   def search_all(query, max_pages=100):
       body, tweets, pages = {"query": query, "order": "latest"}, [], 0
       while pages < max_pages:
           r = requests.post(URL, json=body, headers=HEADERS, timeout=30)
           if r.status_code == 429:  # over 20 requests in one second
               time.sleep(1)
               continue
           r.raise_for_status()  # 403: the key's requests ran out
           page = r.json()
           tweets += page.get("tweets", [])
           pages += 1
           if not page.get("next_cursor"):
               break
           body["next_cursor"] = page["next_cursor"]
           time.sleep(0.05)  # stays under 20 requests per second
       return tweets
   
   print(len(search_all("from:ratelimit_fix_demo")))
   

   const URL = "https://api.sorsa.io/v3/search-tweets";
   const HEADERS = { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" };
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
   
   async function searchAll(query, maxPages = 100) {
     const body = { query, order: "latest" };
     const tweets = [];
     for (let pages = 0; pages < maxPages; ) {
       const res = await fetch(URL, {
         method: "POST",
         headers: HEADERS,
         body: JSON.stringify(body),
       });
       if (res.status === 429) { await sleep(1000); continue; } // over 20 a second
       if (!res.ok) throw new Error(`HTTP ${res.status}`); // 403: out of requests
       const page = await res.json();
       tweets.push(...(page.tweets ?? []));
       pages += 1;
       if (!page.next_cursor) break;
       body.next_cursor = page.next_cursor;
       await sleep(50); // stays under 20 requests per second
     }
     return tweets;
   }
   
   searchAll("from:ratelimit_fix_demo").then((t) => console.log(t.length));
   

4. Watch your balance. GET /key-usage-info (opens in a new tab) returns the requests left and the date they renew, and the check itself is free. A 403 means the key's requests have run out.

#Stop waiting on rate-limit windows

"Rate limit exceeded" on X clears on its own: in 15 minutes for most official X API windows, in a few hours or a day for account caps, and only at the next billing cycle for the 3M post-read cap. If you keep meeting it because your code reads X data, move those reads to Sorsa API: one limit of 20 requests per second per key on every plan, posts from $0.014 per 1,000, and 100 free requests to try it today.

#FAQ