Twitter (X) API rate limits in 2026

#X API rate limits by endpoint in 2026

Every X API v2 endpoint carries its own limit, counted per app and per user, and most of them reset every 15 minutes. The numbers below are the ones X published on November 2, 2026; what each call costs on top of the limit is in our X API pricing breakdown.

Reads allow hundreds or thousands of requests per window, writes are capped per user, and a few endpoints add a 24-hour or a once-per-second limit on top.

• Recent search, last 7 days (100)

  Per app

  450 / 15 min

  Per user

  300 / 15 min

• Full-archive search, back to 2006 (500)

  Per app

  300 / 15 min and 1 / sec

  Per user

  1 / sec

• Posts by ID (100)

  Per app

  3,500 / 15 min

  Per user

  5,000 / 15 min

• One account's posts (100)

  Per app

  10K / 15 min

  Per user

  900 / 15 min

• Mentions of one account (100)

  Per app

  450 / 15 min

  Per user

  300 / 15 min

• Profiles by ID or username (100)

  Per app

  300 / 15 min

  Per user

  900 / 15 min

• Followers or following (1,000)

  Per app

  300 / 15 min

  Per user

  300 / 15 min

• Who liked, reposted or quoted a post

  Per app

  75 / 15 min

  Per user

  75 / 15 min

• Create a post or reply

  Per app

  10K / 24 h

  Per user

  100 / 15 min

• Delete a post

  Per app

  none

  Per user

  50 / 15 min

• Send a direct message

  Per app

  1,440 / 24 h

  Per user

  15 / 15 min and 1,440 / 24 h

Per app means every request signed with your app's Bearer token draws on one shared counter. Per user means each user who authorized your app through OAuth gets a counter of their own, so the same endpoint can show two numbers, such as 450 and 300 for recent search. "X API rate limits" and "Twitter API rate limits" are the same thing: X renamed the product, and the limits here are for X API v2, the version its rate-limit reference covers.

The table is a dated extract. X keeps the full list of more than 100 endpoints, from Lists and Spaces to media upload, in its rate limit reference (opens in a new tab), and the Developer Console shows the limits on your own app.

Good to know

X's reference still lists limits for following, liking and quote-posting, but X removed those writes (opens in a new tab) from every self-serve plan on April 20, 2026. On pay-per-use, those calls fail whatever the window says.

#How long a read job takes at these limits

On one app at full speed, X's windows let you read about 600K posts an hour by full-archive search, 1.4M by ID or 1.2M followers. Pay-per-use, though, stops at 3M post reads a month and bills every one of them.

Each hourly figure is the per-app window times the most results a request returns, four windows an hour: 300 full-archive searches of 500 posts, 3,500 lookups of 100 posts, 300 follower pages of 1,000. Recent search, at 450 requests of 100 posts, reaches 180K posts an hour, from the last 7 days only.

The monthly cap turns those hourly numbers into a short burst. At full speed, lookups by ID reach 3M posts in about 2 hours and full-archive search in about 5, and 3M posts cost $15,000 at X's $0.005 per post. From November 22, 2026, X also bills each author profile you request with a post at the user rate of $0.010 (opens in a new tab).

Sorsa API, a Twitter (X) API and scraper, has one limit instead: 20 requests per second per API key, on every plan. At that limit the same jobs run 2.4 to 60 times faster than on one official X API app:

• Search posts

  Sorsa API, per hour

  about 1.44M, back to 2006

  Official X API, per hour (one app)

  600K by full archive, 180K by recent search

• Posts by ID

  Sorsa API, per hour

  7.2M

  Official X API, per hour (one app)

  1.4M

• Profiles

  Sorsa API, per hour

  7.2M

  Official X API, per hour (one app)

  120K

• Followers

  Sorsa API, per hour

  14.4M

  Official X API, per hour (one app)

  1.2M

The price gap is wider than the speed gap. Tweets cost from $0.014 per 1,000 on Sorsa API against $5.00 on the official X API, followers from $0.007 against $10.00, and failed requests are never charged.

#Read X data at 20 requests per second

To read X data without 15-minute windows, use Sorsa API: one API key in the ApiKey header, no X developer account or OAuth, and every endpoint shares the same limit of 20 requests per second.

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

2. Read 100 tweets in one request. Send up to 100 tweet links or IDs to POST /tweet-info-bulk (opens in a new tab). Each tweet comes back with its author's full profile, and the whole batch counts as one request.

   curl -X POST \
     "https://api.sorsa.io/v3/tweet-info-bulk" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"tweet_links": ["1854021938471002113"]}'
   

   {
     "tweets": [
       {
         "id": "1854021938471002113",
         "full_text": "Weekly digest is out: 48 links, 3 charts.",
         "created_at": "2026-10-30T09:12:44Z",
         "lang": "en",
         "likes_count": 96,
         "retweet_count": 14,
         "reply_count": 9,
         "view_count": 8840,
         "user": {
           "id": "1590087714360229888",
           "username": "ratelimit_lab_demo",
           "display_name": "Rate Limit Lab",
           "followers_count": 2310
         }
       }
     ]
   }
   

   Show full response

3. Pace a big job at 20 a second. The function sends batches in rounds of 20, one round per second, so a list of a million IDs runs at the full limit without a single window to wait for.

   import time
   from concurrent.futures import ThreadPoolExecutor
   
   import requests
   
   URL = "https://api.sorsa.io/v3/tweet-info-bulk"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   RATE = 20  # requests per second, per API key
   
   
   def fetch(batch):
       for _ in range(5):
           r = requests.post(URL, headers=HEADERS,
                             json={"tweet_links": batch}, timeout=30)
           if r.status_code == 429:  # over 20 in this second
               time.sleep(1)
               continue
           r.raise_for_status()
           return r.json()["tweets"]
       raise RuntimeError("still 429 after 5 tries")
   
   
   def read_tweets(ids):
       batches = [ids[i:i + 100] for i in range(0, len(ids), 100)]
       tweets = []
       with ThreadPoolExecutor(max_workers=RATE) as pool:
           for i in range(0, len(batches), RATE):
               started = time.monotonic()
               for page in pool.map(fetch, batches[i:i + RATE]):
                   tweets += page
               time.sleep(max(0, 1 - (time.monotonic() - started)))
       return tweets
   

4. Pick the endpoint for the job. The same limit covers every endpoint, so only the results per request change.

• POST /search-tweets (opens in a new tab) takes X's search operators, back to 2006, about 20 tweets per page with next_cursor to the next one.
• GET /followers (opens in a new tab) returns up to 200 followers per page.
• GET /info-batch (opens in a new tab) returns up to 100 profiles by username or user ID.

The limit resets every second, not every 15 minutes, and Sorsa API sends no rate-limit headers because there is no window to track. A 429 means more than 20 requests in one second: wait a second and send it again, as the rate limit docs (opens in a new tab) describe. A 401 or 403 means the key is wrong, missing or out of requests. How Sorsa API compares with every other way to read X data is in our guide to Twitter API alternatives.

#How X API windows, headers and 429s work

An X API window is a per-endpoint counter that starts with your first request: each call takes one, and at zero X answers 429 Too Many Requests until the window refills.

Every response tells you where the counter stands in three headers:

x-rate-limit-limit: 450
x-rate-limit-remaining: 0
x-rate-limit-reset: 1793606400

x-rate-limit-limit is the size of the window and x-rate-limit-remaining is what is left. x-rate-limit-reset is the moment the window refills, in Unix seconds rather than a countdown. Read them on every response: a call that comes back with 0 remaining has already told you the next one will fail.

Over a limit, X answers 429 with error code 88, "Rate limit exceeded". Waiting until the reset time is the fix; retrying sooner only collects more 429s. The step-by-step fixes, retry code and the "rate limit exceeded" message in the X app are covered in our guide to Twitter rate limit exceeded.

A job that stays under every window can still stop, because the official X API has three layers of limits, and each one ends the job in its own way.

• Endpoint windows reset by themselves, after 15 minutes or 24 hours, and full-archive search also refuses a second request within the same second.
• The monthly cap and your credits don't reset with time: pay-per-use stops at 3M post reads per billing cycle, and requests are blocked once your credit balance or the spending limit you set (opens in a new tab) runs out.
• Account caps belong to the X account, not to the app: they count posts, replies, follows and messages from the X app, the web and the API together.

#X posting limits: per 15 minutes and per day

Posting through the official X API is capped twice: by the endpoint, at 100 posts per user every 15 minutes and 10K per app a day, and by the X account. An unverified account can publish only 50 original posts and 200 replies a day, however the posts are sent.

The account cap binds first. At 100 posts per 15 minutes the endpoint would allow 9,600 posts a day for one user, but an unverified account stops at 50.

• Original post

  Official X API limit

  100 / 15 min per user, 10K / 24 h per app

  X account limit, all apps together

  50 a day, unverified accounts

• Reply

  Official X API limit

  the same endpoint as a post

  X account limit, all apps together

  200 a day, unverified accounts

• Delete a post

  Official X API limit

  50 / 15 min per user

  X account limit, all apps together

  none published

• Repost

  Official X API limit

  50 / 15 min per user

  X account limit, all apps together

  none published

• Direct message

  Official X API limit

  15 / 15 min and 1,440 / 24 h per user

  X account limit, all apps together

  500 a day

• Follow

  Official X API limit

  removed from self-serve, April 20, 2026

  X account limit, all apps together

  400 a day

• Like or quote post

  Official X API limit

  removed from self-serve, April 20, 2026

  X account limit, all apps together

  none published

X's limits page (opens in a new tab) says the account caps count actions "from all devices, including web, mobile, phone, API", so a script and a person typing in the app draw on the same 50 posts. X splits the daily post cap into semi-hourly limits it doesn't publish, and once an account follows 5,000 others, more follows depend on account ratios.

The 50-post cap is recent. X cut it from 2,400 updates a day in May 2026, as PCMag reported (opens in a new tab), and the same help page still names 2,400 in another paragraph. X publishes no daily number for verified accounts. Every post also costs money on pay-per-use: $0.015 per post and $0.20 for a post with a link.

Sorsa API is read-only by design: it never posts, likes, follows or sends messages, and it never asks for your X login or cookies, so your X account carries zero risk from it. To publish, pair it with the official X API, and keep the reading, such as checking that a post went live or collecting its replies and mentions, on Sorsa API.

#Free tier and Enterprise rate limits

The official X API has no free tier in 2026, so it has no free rate limits either. Its posting-only Free tier, last capped at 17 posts per 24 hours (opens in a new tab), closed to new developers on February 6, 2026, when pay-per-use became the default. What it allowed year by year is in our answer to is the Twitter API free.

The paid Basic and Pro plans went the same way: X moved Basic subscribers to pay-per-use after June 1, 2026 and Pro subscribers after September 1. Forum answers that quote Basic's 100 posts a day describe plans nobody can buy now. Everyone on pay-per-use now shares the windows in the first table.

Enterprise is the only way to change them. Enterprise contracts set custom rate limits by agreement and lift the 3M post-read cap; X sells them through an interest form and publishes no price, and when it launched Enterprise access in 2023, contracts were reported from $42,000 a month (opens in a new tab).

#Plan an X data job around one limit

X API rate limits are per endpoint and mostly per 15 minutes, with a 3M monthly post-read cap and the account's daily caps on top, so a big job has to fit three layers at once. For reading X data at scale, use Sorsa API: one limit of 20 requests per second per key, up to 100 tweets or 200 followers per request, from $0.014 per 1,000 tweets. Start with 100 free requests, enough for your first 10K tweets.

#FAQ