Twitter (X) API 1.1 in 2026: What Still Works and Where Each Endpoint Went

- v1.1 is Legacy, not gone: docs.x.com marks it "Legacy, limited support, minimal updates" and recommends X API v2 for all new projects.
- Dated events: free v1.1 and v2 access ended February 2023 (announced Feb 2, 2023), Premium v1.1 (Premium Search, Account Activity API) was deprecated April 20, 2023, and v1.1 media upload moved to v2 in 2025.
- Endpoint map:
statuses/user_timeline→/2/users/:id/tweets→/twitter/user/last_tweets;search/tweets→/2/tweets/search/recent→/twitter/tweet/advanced_search; full table below. - Page sizes we measured:
/twitter/user/followers_idsreturned 5,000 ids per page and/twitter/user/followers200 profiles, the same as v1.1'sfollowers/idsandfollowers/listmaximums; tweet calls return 20 per page withnext_cursor. - Field names:
favorite_count→likeCount,retweet_count→retweetCount,user.screen_name→author.userName; follower lists keep v1.1-style snake_case (screen_name,followers_count,friends_count). - Cost: X pay-per-usage charges $0.005 per post read ($5 per 1,000); TwitterAPI.io charges $0.15 per 1,000 tweets returned, about 33x less on that line, with no OAuth app or X account needed for reads.
Most searches for "Twitter API 1.1" come from one of two places: an old script or library that suddenly returns 403, 410 or 453 errors, or a codebase that still calls api.twitter.com/1.1/... and needs a plan. Tutorials written before 2023 still rank for v1.1 endpoint names, and almost none of them say what happened to those endpoints afterward.
This page does three things. It lays out the v1.1 timeline using only dated announcements from X's own developer accounts and docs.x.com. It maps the v1.1 calls developers used most to their X API v2 equivalent and to a TwitterAPI.io endpoint, saying "no direct equivalent" where there is none. And it shows what those replacement calls actually returned when we ran them: items per page, fields, and measured latency.
If you are starting a new project and only want to understand v2, the Twitter API v2 explainer linked at the end covers that intent. This page is for code that speaks v1.1.
5,000
Is Twitter API 1.1 deprecated? The status in 2026
X's own documentation answers this in two places. The versioning page at docs.x.com/x-api/fundamentals/versioning has a "Current versions" table with three rows: v2 is "Current", v1.1 is "Legacy" with "Limited support, minimal updates", and Enterprise is "Available". The same page tells new projects to use X API v2, "where all new features ship".
The migration overview at docs.x.com/x-api/migrate/overview goes one step further: it says X API v2 "is now the primary X API", strongly encourages customers of the legacy APIs (v1.1 and enterprise) to begin migrating, and states that X intends to deprecate them eventually. It gives no date.
So the precise answer is: v1.1 as a whole is legacy rather than retired, but many individual v1.1 endpoints and every free path to them are already gone. The legacy reference pages on developer.x.com now return HTTP 402 to anonymous fetches, which is one more sign that v1.1 documentation is no longer maintained in the open.
What "legacy" means in practice. X's versioning page defines a deprecated version as one with "no new features; critical bugs only", and retired as "no longer accessible". New X features (edit history, community notes fields, new metrics) arrive in v2 only. If your product depends on a field that did not exist in 2022, v1.1 will not grow it.
The v1.1 timeline, from X's own announcements
Every event below comes from a post by X's developer accounts (@XDevelopers, formerly @TwitterDev, and @API) that we retrieved through the API, or from docs.x.com. Where a date was later extended, both dates are given.
Two things follow from this list. First, the death of v1.1 was not one event: access was cut by pricing in 2023, then endpoints moved one family at a time. Second, the endpoints that people relied on longest were the write-side ones, especially media upload, because X API v2 had no media upload endpoint until January 2025. On May 23, 2022, @XDevelopers was still adding video, GIF and alt-text support to the v1.1 media endpoints "while we continue to work to deliver the v2 media endpoints".
Third-party integrators reported slightly different final cutover dates for media upload in mid-2025. We list only the dates X posted itself; if you maintain an uploader, test it against /2/media/upload rather than trusting any single date.
Twitter API 1.1 endpoint map: v1.1 to X API v2 to TwitterAPI.io
The X API v2 column follows X's official endpoint map at docs.x.com/x-api/migrate/x-api-endpoint-map and the path names in X's OpenAPI file. The TwitterAPI.io column lists only endpoints that exist in our published API; where there is no equivalent we say so.
Reads need no X account. Every read call in the TwitterAPI.io column takes a username, user id or tweet id and one X-API-Key header. There is no OAuth 1.0a signature, no consumer key pair and no bearer token exchange, which is usually the largest chunk of v1.1 code to delete.
Mentions of any account. v1.1 statuses/mentions_timeline only returned mentions of the authenticating user. /twitter/user/mentions takes a userName, so the same call works for any public account, and it accepts sinceTime and untilTime for windows.
Writes are a separate product with a session. POST statuses/update and POST media/upload map to write endpoints that act as a real X account. You log in once with /twitter/user_login_v2 ($0.10, using a proxy you supply), which returns login_cookies; each post, delete, like, retweet, follow or media upload is then 60 credits ($0.0006) and is billed per HTTP 200 call. The call acts as that account, so X can rate-limit, lock or suspend it; keep a normal human pace, use only your own account, and expect the session to need a fresh login from time to time.
What the replacement calls actually return (our test)
Documentation tells you the path; it does not tell you what comes back. So we ran the TwitterAPI.io replacement for ten v1.1 calls against ten organization accounts (NASA, GitHub, Vercel, Docker, NVIDIA, Xbox, PlayStation, Spotify, Google, Microsoft): 89 requests, 825 tweets, 3,592 profiles and 50,000 follower ids.
Follower calls behave like v1.1. The documented v1.1 maximum for followers/ids was 5,000 ids per request and for followers/list and friends/list 200 users per page. The replacements returned exactly 5,000 ids and 200 profiles per page on every account that had that many, so loops written around v1.1 page sizes keep their arithmetic.
Tweet calls page by 20. v1.1 let statuses/user_timeline ask for up to 200 tweets and search/tweets up to 100 per request. Our tweet endpoints return 20 per page and a next_cursor, and has_next_page was true on 100% of timeline pages. Replace count=200 with a cursor loop that stops when has_next_page is false; the code below does this.
Batch tweet lookups were the slow outlier. /twitter/tweets with ten ids took 9.0 s in our two batch requests, against 1.9 s for single ids. Two requests is too few to call it a pattern, but if you replaced statuses/lookup with large batches, measure on your own traffic.
Lookup returns a richer tweet object. Tweets fetched by id carried 39 top-level keys against 29 on timeline and search pages, adding fields such as isRetweet, isQuote, isPinned and editControl.
Date-bounded search reaches back years. While building the timeline above, /twitter/tweet/advanced_search with from:XDevelopers since:2023-02-01 until:2023-02-03 returned the February 2, 2023 post that announced the end of free v1.1 access, so date-bounded queries reach years back.

Field mapping: v1.1 names to TwitterAPI.io names
Most v1.1 migrations fail in the parser, not the request. The v1.1 tweet object used snake_case (favorite_count, id_str, user.screen_name); our tweet objects use camelCase, and our follower lists keep snake_case. Every row below was checked against the keys our study actually received.
The created_at string survives. Our createdAt uses the same Ruby-style timestamp v1.1 used, so datetime.strptime(s, "%a %b %d %H:%M:%S %z %Y") keeps working. v2 switched to ISO 8601, which is one of the more common breakages when moving to X's v2.
Do not look for public_metrics. That is X API v2's nesting. Our counts are top-level keys on the tweet.
If you have hundreds of call sites reading v1.1 keys, a shim that renames our fields back to v1.1 names lets you migrate the transport first and the parser later:
def to_v11_tweet(t):
"""Map a TwitterAPI.io tweet to the v1.1 field names old code expects."""
a = t.get("author") or {}
return {
"id_str": t["id"],
"full_text": t["text"],
"created_at": t["createdAt"], # same "Thu Oct 16 12:34:56 +0000 2026" format
"favorite_count": t.get("likeCount", 0),
"retweet_count": t.get("retweetCount", 0),
"reply_count": t.get("replyCount", 0),
"quote_count": t.get("quoteCount", 0),
"in_reply_to_status_id_str": t.get("inReplyToId"),
"in_reply_to_screen_name": t.get("inReplyToUsername"),
"lang": t.get("lang"),
"user": {
"id_str": a.get("id"),
"screen_name": a.get("userName"),
"name": a.get("name"),
"followers_count": a.get("followers"),
"friends_count": a.get("following"),
},
"extended_entities": t.get("extendedEntities") or {},
}
Migration code for the six most-used v1.1 calls
The full program is in the code block at the end of this page: user_timeline, search, lookup_tweets, user_show, follower_ids and mentions, each with the v1.1 request it replaces written as a comment above it. Three patterns cover almost every change.
Authentication collapses to one header. Delete the OAuth 1.0a signer, the consumer key and secret, and the access token pair. Every request carries X-API-Key.
count becomes a cursor loop. Send cursor (empty on the first call), read next_cursor, stop when has_next_page is false. v1.1 max_id / since_id arithmetic is not needed; for time windows on search, put since: and until: in the query, and on mentions use sinceTime / untilTime.
Screen names work directly. v2 needs a numeric user id for timelines and followers, so most v2 migrations add a users/by/username lookup first. Our timeline, follower and mention calls take userName, which matches how v1.1 code passed screen_name.
Error handling changes shape. An unknown user on /twitter/user/info returns HTTP 200 with status: "error" and msg: "user not found". A missing parameter returns HTTP 400 with the text in detail. Check status before reading data.
Here is the follower-list loop for code that used tweepy 3.x cursors against v1.1:
# v1.1 cursor loop (tweepy 3.x style), for the record:
# for page in tweepy.Cursor(api.followers, screen_name="NASA", count=200).pages():
# for u in page: print(u.screen_name, u.followers_count)
#
# Same loop on TwitterAPI.io: snake_case keys, 200 profiles per page, string cursor
import requests
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": "YOUR_TWITTERAPI_IO_KEY"}
cursor = ""
for _ in range(3):
body = requests.get(f"{BASE}/twitter/user/followers",
headers=HEADERS,
params={"userName": "NASA", "cursor": cursor},
timeout=40).json()
for u in body["followers"]:
print(u["screen_name"], u["followers_count"], u["created_at"])
if not body.get("has_next_page"):
break
cursor = body["next_cursor"]
Cost: X API v2 vs TwitterAPI.io for a former v1.1 workload
Before February 2023, standard v1.1 reads were free within rate limits, so many v1.1 projects were never budgeted. Both routes now bill per item. X publishes its pay-per-usage rate card at docs.x.com/x-api/getting-started/pricing: $0.005 per post read, $0.010 per user read and $0.010 per follower or following read, capped at 3 million post reads a month before Enterprise applies. TwitterAPI.io charges $0.15 per 1,000 tweets returned, $0.18 per 1,000 profiles, and 1 to 3 credits per follower returned.
On the tweet line that is $5 against $0.15 per 1,000, about 33x. A timeline or search check that returns no tweets is billed the 15-credit minimum ($0.00015); a full 20-tweet page costs $0.003. Polling one account every 60 seconds for a month is 43,200 checks, $6.48 even if nothing new appears, and every 5 minutes is $1.30.
Rate limits also changed shape. v1.1 limits were per 15-minute window per endpoint (900 user-auth requests for statuses/user_timeline, 15 for followers/ids, per the legacy reference). Ours are per second for the whole key: 0.2 requests per second before the first payment, 20 once paid, 50 on Scale, 500 on Business and up to 1,000 on request. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days); purchased credits never expire. Plan details are on the pricing page.
Choosing a route: v2, TwitterAPI.io, or both
Stay with X directly if you need write access through X's own OAuth consent screen for many end users, compliance streams, Ads API workflows, or an enterprise contract with X. X's v2 is the supported path for those and the official endpoint map is the place to start.
Use TwitterAPI.io if the v1.1 code is a reader: timelines, search, profile lookups, follower exports, mention monitoring. You keep screen-name-based calls, v1.1-like follower page sizes and timestamp formats, and you skip the developer app review and OAuth setup.
Mixed setups are common. Some teams keep a small X API v2 app for posting through their own users' OAuth tokens and move bulk reads to TwitterAPI.io. The two do not conflict; they are separate keys and separate bills.
A migration checklist that works for either route. Inventory every /1.1/ URL in your code and libraries (tweepy 3.x, twitter4j, twit and python-twitter all wrap v1.1). Replace authentication. Replace count and max_id loops with cursor loops. Rename fields or add the shim above. Re-test error handling for missing users and protected accounts. Then compare a day of output from old and new code before switching traffic.
How we collected this
Question. When the most-used Twitter API v1.1 read calls are replaced by TwitterAPI.io endpoints, what does each replacement return: items per page, pagination, fields, payload size and round-trip latency?
Accounts and calls. Ten organization accounts (NASA, GitHub, Vercel, Docker, NVIDIA, Xbox, PlayStation, Spotify, Google, Microsoft). Per account: one profile lookup, two timeline pages, one from: search page, one page each of follower ids, followers, followings and mentions; plus two batch tweet lookups, two batch profile lookups and five single tweet lookups. 89 requests in total, collected in 2026.
Timing. Our script timed each request from the moment the shared rate limiter released it to the moment the JSON body was parsed, so queueing behind our own 5 requests per second budget is excluded. Five other jobs were sharing that budget at the time.
What the sample cannot show. Latency was measured from one client location over a short window; your region, network and time of day will change it, and it is not a service-level figure. Ten accounts are large, active organizations; small or protected accounts may page differently. Batch lookups were run only twice each.
Privacy. Aggregates only. Raw pages are kept only for organization profiles and timelines; follower, following, mention and search pages, which contain private individuals, were analyzed in memory and only counts and key names were kept.

import time
import requests
API_KEY = "YOUR_TWITTERAPI_IO_KEY"
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": API_KEY} # replaces OAuth 1.0a signing and bearer tokens
def get(url, params):
r = requests.get(url, headers=HEADERS, params=params, timeout=40)
r.raise_for_status()
return r.json()
# 1. v1.1: GET statuses/user_timeline.json?screen_name=NASA&count=200
def user_timeline(user, max_pages=5):
tweets, cursor = [], ""
for _ in range(max_pages):
body = get(f"{BASE}/twitter/user/last_tweets", {"userName": user, "cursor": cursor})
tweets += body["data"]["tweets"]
if not body.get("has_next_page"):
break
cursor = body["next_cursor"]
return tweets
# 2. v1.1: GET search/tweets.json?q=from:NASA&result_type=recent&count=100
def search(query, max_pages=3):
tweets, cursor = [], ""
for _ in range(max_pages):
body = get(f"{BASE}/twitter/tweet/advanced_search",
{"query": query, "queryType": "Latest", "cursor": cursor})
tweets += body["tweets"]
if not body.get("has_next_page"):
break
cursor = body["next_cursor"]
return tweets
# 3. v1.1: GET statuses/lookup.json?id=1,2,3 (and statuses/show.json?id=1)
def lookup_tweets(ids):
return get(f"{BASE}/twitter/tweets", {"tweet_ids": ",".join(ids)})["tweets"]
# 4. v1.1: GET users/show.json?screen_name=NASA
def user_show(user):
body = get(f"{BASE}/twitter/user/info", {"userName": user})
if body.get("status") == "error": # unknown users come back as HTTP 200 + msg
raise LookupError(body.get("msg"))
return body["data"]
# 5. v1.1: GET followers/ids.json?screen_name=NASA&count=5000
def follower_ids(user, max_pages=2):
ids, cursor = [], ""
for _ in range(max_pages):
body = get(f"{BASE}/twitter/user/followers_ids", {"userName": user, "cursor": cursor})
ids += body["ids"]
if not body.get("has_next_page"):
break
cursor = body["next_cursor"]
return ids
# 6. v1.1: GET statuses/mentions_timeline.json (authenticated user only)
def mentions(user):
return get(f"{BASE}/twitter/user/mentions", {"userName": user})["tweets"]
if __name__ == "__main__":
t0 = time.time()
tl = user_timeline("NASA", max_pages=1)
for t in tl[:3]:
# v1.1 names in the comment, new names in the code
# favorite_count -> likeCount, retweet_count -> retweetCount, user.screen_name -> author.userName
print(t["createdAt"], t["author"]["userName"], t["likeCount"], t["retweetCount"], t["text"][:60])
print("search:", len(search("from:NASA", max_pages=1)))
print("lookup:", len(lookup_tweets([t["id"] for t in tl[:5]])))
u = user_show("NASA")
print("profile:", u["userName"], u["followers"], u["statusesCount"])
print("follower ids:", len(follower_ids("NASA", max_pages=1)))
print("mentions:", len(mentions("NASA")))
print(f"done in {time.time() - t0:.1f} s")
Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.
Questions readers ask
Is Twitter API 1.1 still working in 2026?
Partly. X's versioning page lists v1.1 as Legacy with limited support and minimal updates, and says X intends to deprecate it eventually. Free access ended in February 2023, Premium v1.1 (Premium Search and Account Activity API) was deprecated on April 20, 2023, and the v1.1 media upload endpoints were replaced by X API v2 media endpoints in 2025. Any remaining v1.1 access requires a paid X developer account.
What replaced statuses/user_timeline?
On X's side, GET /2/users/:id/tweets (the user Post timeline), which needs a numeric user id and returns up to the 3,200 most recent posts. On TwitterAPI.io, /twitter/user/last_tweets takes a userName or userId, returns 20 tweets per page with next_cursor, and bills $0.15 per 1,000 tweets returned.
Why does my old v1.1 code return 403 errors?
A 403 that mentions your access level usually means the app's access level no longer includes that v1.1 endpoint. Since the 2023 tier change, standard v1.1 access is no longer sold as its own tier, so code written for a free or Standard v1.1 app will be refused until it moves to a v2 endpoint on a paid X plan or to another provider.
Can I still upload media with the v1.1 endpoint?
X launched v2 media upload endpoints in January 2025 and told self-serve developers the legacy v1.1 media upload endpoints would be deprecated, with the migration timeline extended to April 30, 2025. New code should use POST /2/media/upload, or on TwitterAPI.io /twitter/upload_media_v2 through a logged-in session, which acts as that account and is billed at 60 credits ($0.0006) per HTTP 200 call.
Do I need a Twitter developer account to replace v1.1 reads with TwitterAPI.io?
No. Reads need only a TwitterAPI.io API key in the X-API-Key header; no X account, X developer app or OAuth tokens are involved. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days).
Are the v1.1 field names the same on TwitterAPI.io?
Tweet fields are renamed to camelCase (favorite_count becomes likeCount, user.screen_name becomes author.userName), but the createdAt timestamp keeps the v1.1 string format. Follower and following lists keep v1.1-style snake_case keys such as screen_name, followers_count and friends_count.
What happened to Twitter API v1 (not 1.1)?
API v1.0 was retired in June 2013, when X (then Twitter) made v1.1 the only REST version and requests to the old /1/ paths began returning HTTP 410 Gone. "Twitter API v1" searches today usually mean v1.1.
Continue
- X API docs: Versioning (v1.1 listed as Legacy, limited support, minimal updates)
- X API docs: Migration overview (v2 is the primary X API; legacy APIs to be deprecated eventually)
- X API docs: endpoint map from Standard v1.1 and Enterprise to X API v2
- @XDevelopers, February 2, 2023: end of free access to v2 and v1.1
- @XDevelopers, April 20, 2023: Premium v1.1 API deprecated, including Premium Search and Account Activity API
- X API docs: pay-per-usage pricing (post, user and follower read rates)
- Twitter (X) API overview and endpoint catalog
- Twitter API v2 explained: differences from v1.1
- Complete Python guide to the Twitter API
- Migrating a tweepy project to TwitterAPI.io
- Cursor pagination with next_cursor and has_next_page
- How to get an X API key
- TwitterAPI.io API reference documentation
- 01How to Make Your Twitter (X) Account Private, and Public Again
- 02How to change your Twitter (X) font: text size, Chirp, and Unicode "fancy fonts"
- 03Twitter (X) Enterprise API: What It Includes, Who Needs It, and What It Costs
- 04Twitter (X) Account Activity API: What It Was, Its End of Life, and What Replaces It
- 05Sensitive Content Warning on Twitter (X): How to See, Turn Off, or Keep It
- 06Twitter (X) API Cost — A Straight Answer
- 07Hootsuite Pricing 2026: Plans, Per-Seat Costs and What You Get for Twitter (X)
- 08Twitter (X) Sentiment Analysis in Python: Pull Posts, Score Them, Compare Two Scorers
Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API keyAlready building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.