Twitter (X) API News: Every Official Change, What It Costs Now, and What It Means for You

Searching for X API news usually lands you on a press write-up of one change, a forum thread, or a vendor's pricing page that quietly inherited last year's numbers. This page is built the other way round: every row in the tracker below was read this session on docs.x.com/changelog or on the official pricing page at docs.x.com/x-api/getting-started/pricing, ordered newest first, with the exact month (and day where the entry states it), the price or rule as it stands now, and a one-line answer to the question that actually matters to a third-party API user: does this touch me, and what does the same read cost on each side.
Behind the tracker is a small study nobody else publishes. We pulled the 200 most recent posts of @XDevelopers and of @API, X's two official developer accounts, through /twitter/user/last_tweets in 2026 and classified each post with a transparent keyword rule into pricing and billing, new endpoint or feature, deprecation, rate limits, policy, events, or other. That gives a measured answer to "how often does the X API change?": posts per month, the share of announcements, the median gap between them, and which topics developers react to. The @API account turned out to be effectively dormant (its 200 posts stretch back to 2014), which is itself a useful data point about where to look.
The page is about what X has officially changed and what it means for people who read or write X data through an API. It is not an opinion piece about X's strategy, and it does not repeat figures we could not verify from a primary source; where a widely reported detail is not on docs.x.com, it is attributed or omitted. For the full official rate card with worked examples, see our X API cost breakdown; for the documentation map, our X API docs index.
What the official X API costs right now
The official X API is sold pay-per-usage, "with no subscriptions", on docs.x.com/x-api/getting-started/pricing. Reads are billed per resource returned and writes per request. The numbers below are the page as it reads today; the rows that changed recently are explained in the tracker further down.
Two rules sit around the card. Pay-per-use is "capped at 3 million Post reads per monthly billing cycle", with Enterprise above that; and new pay-per-use accounts earn "$20 in free X API credits when you save your first eligible payment card and complete your first credit purchase" plus "a match of your first auto-recharge up to $50". Rate limits are still expressed per endpoint in 15-minute (sometimes 24-hour) windows, per app or per user, reported in the x-rate-limit-limit, x-rate-limit-remaining and x-rate-limit-reset headers; the rate-limit page lists, for example, 450 requests per 15 minutes per app on /2/tweets/search/recent and does not vary the numbers by plan, noting only that Enterprise customers have custom limits.
The comparison in one line. A post read is $0.005 on the official rate card, so 1,000 posts are $5.00. On twitterapi.io tweet endpoints bill 15 credits per tweet returned, $0.15 per 1,000 tweets, with a 15-credit ($0.00015) minimum per request and no monthly cap: about 33x less per 1,000 posts. Profiles are 18 credits each ($0.18 per 1,000) against $10.00 per 1,000 user reads. You pay only for the data returned, and reads need no X account.
X API changes tracker: newest first
Every entry below is on docs.x.com/changelog (quoted) or in the post history of X's official developer accounts that we collected for the study. "You" in the last column is a twitterapi.io user reading X data without an X developer account; write actions through an authenticated session are called out where a change touches them.
A few widely reported details are deliberately not in the table because they are not on docs.x.com: the dollar figures of the retired Basic and Pro subscriptions and the exact terms under which existing subscribers were migrated. Trade press reported at the launch that existing free-plan users received a one-time voucher and that public-utility apps keep free access; treat those as reported, not verified.
The changelog text for the February 2026 launch says there are "no monthly object caps", while the pricing page says pay-per-use is "capped at 3 million Post reads per monthly billing cycle". The pricing page is the rate card, so the table prints the cap; if you expect to exceed 3 million post reads a month, the official route is Enterprise.
How often does the X API actually change? 200 posts from @XDevelopers
To put a number on "the X API changes all the time", we pulled the 200 most recent posts of @XDevelopers (10 pages of /twitter/user/last_tweets, replies excluded by default) in 2026. They span 17 full calendar months. Each post, or the original behind a repost, was assigned the first topic whose keyword list it matched, in a fixed order: pricing and billing, deprecation or retirement, rate limits, policy or terms, new endpoint or feature, events or community, other. The lists are printed in results.json and in analyze.py, so the rule is reproducible and its limits are visible.
Cadence. The account posted a median of 12 times a month, from 3 in the quietest month to 21 in the busiest. 124 of the 200 posts (62%) were announcements under the rule (any topic except events and other), which works out to about 7.3 announcements a month. The median gap between consecutive announcements was 1.0 day, the 90th percentile 13.6 days, and the longest silence 31.8 days. Announcements cluster: several posts land on a launch day, then a week or two passes.
Topics. New endpoint or feature posts were 35.5% of the sample (71 posts), pricing or billing 21.0% (42), events or community 13.5% (27), policy or terms 3.5% (7), rate limits or quotas 1.5% (3), deprecation or retirement 0.5% (1), and 24.5% matched no list. Restricted to the 34 original (non-repost) posts, features rise to 44.1% and pricing to 26.5%. Note what the rule counts as pricing: any post that mentions credits or a dollar amount, which includes the free-credit promotions, so the 21% is "posts about money", not "price changes". Pricing posts came about 2.5 a month, with a median gap of 0.7 days between them and a longest gap of 95 days.
Who is talking. 78.5% of the posts were reposts, mostly of X Developer Platform staff announcing on their own accounts, and 14.0% of posts carried a link to docs.x.com, developer.x.com or devcommunity.x.com. The practical lesson for anyone building a change watch: watch the changelog for the facts and the staff accounts for the early signal; the organization account mostly amplifies.
Likes and views of a repost are those of the original post. Groups under 10 posts are indicative only.

Developers react to prices, not features
Engagement by topic tells you what the audience of X API news cares about. Pricing and billing posts drew a median of 288 likes, 24.5 reposts, 24.5 replies and 51,799 views. New endpoint or feature posts, the largest group, drew a median of 136 likes and 27,847 views; events and community posts 114 likes. The three rate-limit posts had a median of 296 likes and 121,821 views, and the single deprecation post 134 likes and 87,046 views; those groups are too small to generalize, but their direction matches the pricing group: anything that touches cost or access travels further than a launch.
The outliers point the same way. The most liked post in the sample (10,457 likes) is a feature post, but the top of the pricing group reached 5,599 likes and, in the @API account's older history, the single most reposted item of all is the February 2023 notice that free access would end, at 18,947 reposts. If you run a product on the X API, the signal to budget engineering time for is a pricing or access post, not a new field.
@API is effectively dormant. The second official account, @API, gave us 200 posts that stretch from July 2014 to November 2025: 28 posts in 2015, 13 in 2022, 7 in 2023, 8 in 2024 and 4 in 2025, 38% of them reposts of @XDevelopers or @TwitterDev. Under the keyword rule its history is 80 feature posts, 27 deprecation or retirement posts and 6 pricing posts, which is what you would expect from the account that announced v1.1 retirements. For current X API news it is the wrong account to watch.

Official tier prices vs pay-per-use on twitterapi.io, read by read
The tracker's last column keeps saying "unaffected"; this table shows why, using only the two published rate cards: the official pay-per-use page on docs.x.com and the twitterapi.io pricing page ($1 = 100,000 credits).
Subscriptions on twitterapi.io (Starter $29, Builder $99, Pro $199, Scale $499, Business $1,499 a month) add bonus credits and higher request rates; the per-read prices above do not change with the plan, so the ratio against the official card is the same at every volume: $5.00 against $0.15 per 1,000 posts, about 33x. The details, and the credit bonus per plan, are on /pricing.
Build your own X API change watch in 40 lines
The study code generalizes into a small watcher: pull the latest page of @XDevelopers, keep the IDs you have seen, classify anything new with the same keyword rule, and alert on pricing, deprecation, rate-limit or policy posts. One page of 20 posts is $0.003; the account posts about 12 times a month, so a check every six hours ($0.012 a day) will rarely miss a day.
Why the timeline endpoint here and not search. For a single account that posts a dozen times a month, one /twitter/user/last_tweets page per check is the simplest correct call and the 20-post overlap makes a missed post almost impossible. If you watch many staff accounts at once, switch to /twitter/tweet/advanced_search with from:a OR from:b since_time:<unix>; an idle pass then costs the $0.00015 minimum. Either way, read data.tweets[] for the timeline endpoint and top-level tweets[] for search, follow has_next_page and next_cursor only when you need history, and use retweeted_tweet.text for the full text of a repost.
What to do with an alert. Open docs.x.com/changelog and read the entry before acting; the post is the signal, the changelog is the fact. Pricing changes on the official side have so far been announced there on the day, and effective dates (April 20, 2026 for Owned Reads) are stated in the entry.
The script at the end of this page is the complete watcher; it runs once per invocation so it fits a cron line or a GitHub Actions schedule.
Where to read X API news first-hand
docs.x.com/changelog. The canonical list, one dated entry per change back to 2018, with the exact wording that this page quotes. The old docs.x.com/x-api/changelog path returns 404; use the top-level one. There is no RSS feed on the page, which is why the watcher above exists.
docs.x.com/x-api/getting-started/pricing. The rate card. It carries no dates, so a change there is only visible by diffing; the changelog entry usually lands the same day.
@XDevelopers. The official account; 78.5% reposts of staff, so the people it reposts are the earlier signal. Announcements arrive about 7 times a month in our sample.
devcommunity.x.com. The developer forum, where staff post migration threads and developers report breakage; 14.0% of @XDevelopers posts in our sample linked to one of X's developer domains.
console.x.com. The Developer Console introduced with pay-per-use; your usage and credit balance live here, so a billing change shows up in your own numbers before anyone writes about it.
For the third-party side, docs.twitterapi.io is the twitterapi.io reference, and our error 429 guide covers what to do when either API tells you to slow down.
How we collected this
Question: how often does the official X API change, judging by what X's own developer accounts announce: posts per month, share of posts by topic, median gap between announcement posts, and engagement by topic.
Accounts: @XDevelopers and @API, both official X organization accounts.
Method: /twitter/user/last_tweets with the default includeReplies (replies excluded), 10 pages of 20 per account, newest first: 20 requests, 400 posts, $0.06 in API reads, collected in 2026 through a rate-limited, read-only client. For reposts and quotes the original post's text and engagement counts were used. Each post was assigned the first topic whose keyword list matched its lower-cased text, in the order pricing and billing, deprecation or retirement, rate limits, policy or terms, new endpoint or feature, events or community, other. Posts per month use complete calendar months only (the oldest partial month is dropped). Gaps are measured between consecutive announcement posts (any topic except events and other). The changes tracker itself was built from docs.x.com/changelog and the official pricing page, read this session, not from the posts.
What the sample cannot show: 200 posts is a 17-month window for @XDevelopers and an 11-year, very sparse one for @API, so neither is a complete history. A keyword rule is transparent but blunt: a post that mentions "free credits" counts as pricing, a launch post that never uses a launch word falls into other (24.5% did), and the deprecation, rate-limit and policy groups are too small (1, 3 and 7 posts) for their medians to mean much. Engagement counts were read at collection time and change afterwards. The study measures what X announces on one channel, not every change X ships; the changelog has entries that no post mentions.
Aggregates only. The accounts named are X's own organization accounts; the staff accounts reposted by @XDevelopers were not analyzed individually. The analysis script, results, and the gzip-compressed raw pages are kept with the study.
"""x_api_news_watch.py - alert when @XDevelopers posts about pricing, deprecations, rate limits or policy.
pip install requests
export TWITTERAPI_IO_API_KEY=... # twitterapi.io dashboard
python x_api_news_watch.py # one pass; run it from cron every few hours
Cost: one /twitter/user/last_tweets page per pass = 20 posts x 15 credits = $0.003.
Four passes a day is about $0.012. No X developer account is needed to read.
"""
import json
import os
import sys
from datetime import datetime
import requests
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_API_KEY"]}
ACCOUNT = "XDevelopers"
STATE_FILE = "x-api-news-seen.json"
# Same transparent rule as the study on this page: first matching topic wins.
RULE = [
("pricing_billing", ["price", "pricing", "pay-per-use", "pay per use", "credit", "$", "free tier",
"basic tier", "pro tier", "subscription", "billing", "voucher", "discount", "cost"]),
("deprecation_retire", ["deprecat", "retire", "sunset", "removed", "removing", "no longer", "shutting down",
"end of life", "legacy", "migrat"]),
("rate_limits", ["rate limit", "rate-limit", "quota", "msgs/day", "per day", "throttl", "429", " cap"]),
("policy_terms", ["policy", "terms", "spam", "abuse", "enforc", "rules", "manipulation", "suspend",
"compliance", "developer agreement", "summoned", "moderat"]),
("new_endpoint_feature", ["endpoint", "now available", "now live", "is live", "introducing", "launch", "new ",
"xdk", "sdk", "mcp", "playground", "console", "field", "event", "beta", "rebuilt"]),
]
ALERT_ON = {"pricing_billing", "deprecation_retire", "rate_limits", "policy_terms"}
def classify(text):
t = text.lower()
for topic, keywords in RULE:
if any(k in t for k in keywords):
return topic
return "other"
def latest_posts(account, pages=1):
"""Newest first. The timeline endpoint nests the list under data.tweets."""
out, cursor = [], None
for _ in range(pages):
params = {"userName": account}
if cursor:
params["cursor"] = cursor
r = requests.get(f"{BASE}/twitter/user/last_tweets", headers=HEADERS, params=params, timeout=30)
r.raise_for_status()
body = r.json()
if body.get("status") == "error":
raise RuntimeError(body.get("msg"))
page = (body.get("data") or {}).get("tweets") or []
out.extend(page)
if not page or not body.get("has_next_page") or not body.get("next_cursor"):
break
cursor = body["next_cursor"]
return out
def load_seen():
if os.path.exists(STATE_FILE):
with open(STATE_FILE) as f:
return set(json.load(f))
return set()
def main():
seen = load_seen()
first_run = not seen
posts = latest_posts(ACCOUNT)
alerts = []
for p in posts:
if p["id"] in seen:
continue
seen.add(p["id"])
if first_run:
continue # seed the state without alerting on history
original = p.get("retweeted_tweet") or p # a repost's own text is cut short
text = original.get("text") or ""
topic = classify(text)
if topic in ALERT_ON:
when = datetime.strptime(p["createdAt"], "%a %b %d %H:%M:%S %z %Y")
alerts.append((when, topic, p.get("url") or p.get("twitterUrl"), text[:140].replace("\n", " ")))
with open(STATE_FILE, "w") as f:
json.dump(sorted(seen)[-500:], f)
for when, topic, url, text in sorted(alerts):
print(f"[{topic}] {when:%Y-%m-%d %H:%M} {url}\n {text}")
if alerts:
print("-> read the entry on docs.x.com/changelog before changing anything", file=sys.stderr)
print(f"{len(posts)} posts checked, {len(alerts)} alert(s)", file=sys.stderr)
if __name__ == "__main__":
main()
Questions readers ask
What is the latest X API news?
As of the most recent entry we verified on docs.x.com/changelog, pay-per-use accounts earn $20 in credits when they save a first eligible payment card and complete a first purchase, plus a match of the first auto-recharge up to $50 (October 2, 2026). Before that: 23 new X Chat endpoints and a rebuilt Livestream API (September 2026), the X Chat API (July 2026), the new search index with min_likes: restored (May 2026) and Owned Reads at $0.001 (effective April 20, 2026).
How much does the X API cost now?
The official rate card is pay-per-usage: $0.005 per post read, $0.010 per user, follower or DM-event read, $0.001 for reads of your own data, $0.015 per post created ($0.20 if the post contains a URL), with no subscription and a cap of 3 million post reads per monthly billing cycle (Enterprise above). On twitterapi.io the same post read is 15 credits, $0.15 per 1,000 tweets returned, about 33x less per 1,000; see /pricing.
Did X get rid of the free API tier?
Free access to the Twitter API ended in February 2023 (the @TwitterDev notice is the most reposted item in the @API history we collected, 18,947 reposts). Like and follow endpoints were removed from the remaining Free tier on August 22, 2025, and since February 6, 2026 new developers start on pay-per-use, which has no free read allowance. What remains free on the official side is the $20 plus up to $50 in credits that require a saved card.
What changed in the X API in 2026?
Pay-per-use launched publicly on February 6 with a new Developer Console and XDKs; programmatic replies were restricted to summoned replies on February 23; the Account Activity replay endpoint was deprecated on March 20; Owned Reads pricing of $0.001 took effect April 20; search moved to a new index with min_likes:, min_replies: and min_reposts: on May 4; Articles endpoints, X Chat, Livestream and more X Activity API events followed; and the $20 + $50 credit offer was added on October 2. All entries are quoted in the tracker above.
How often does the X API change?
In our 2026 sample of the 200 most recent @XDevelopers posts, the account posted a median of 12 times a month over 17 full months, 62% of posts were announcements, and the median gap between announcements was 1.0 day with a 90th percentile of 13.6 days. The docs.x.com changelog shows 24 dated entries in the first ten months of 2026.
Do X API pricing changes affect twitterapi.io users?
Not directly: twitterapi.io prices are published on its own pricing page (15 credits per tweet returned, 18 per profile, 1 to 3 per follower, $1 = 100,000 credits) and reads need no X developer account. Changes to X's platform rules can affect write actions on any route, because a post, like or follow sent through an authenticated session acts as that X account.
Where is the official X API changelog?
At docs.x.com/changelog, one dated entry per change back to 2018. The pricing page at docs.x.com/x-api/getting-started/pricing carries no dates. The older path docs.x.com/x-api/changelog returns 404. There is no RSS feed, so a small watcher like the script on this page is the practical way to get alerts.
Is the X API rate limit different on pay-per-use?
The rate-limit page on docs.x.com still expresses limits per endpoint in 15-minute or 24-hour windows, per app or per user (for example 450 requests per 15 minutes per app on recent search), with the usual x-rate-limit-* headers, and does not list different numbers for pay-per-use; it notes only that Enterprise customers have custom limits. On twitterapi.io the limit is per account: 0.2 requests per second before the first payment, 20 once paid, higher on the Scale and Business plans.
Continue
- X Developer Platform changelog (dated entries quoted in the tracker)
- X API pay-per-usage pricing (the official rate card, 3M post-read cap, credit offers)
- X API rate limits (15-minute windows, headers, per-endpoint table)
- @XDevelopers, the official X Developer Platform account measured in the study
- twitterapi.io API reference: last_tweets, advanced_search and response fields
- twitterapi.io pricing: credits per tweet, profile and follower, plans and rate limits
- X API hub: endpoints, pricing and guides
- What the X (Twitter) API costs in 2026, read by read
- X API docs: a documentation index
- Can you still use the X API for free?
- Error 429 on the Twitter (X) API: causes and fixes
- TwitterAPI.io vs the official X API, compared
- Pay-per-use pricing and plans
- 01How to Get a Grok API Key: Setup, Pricing and Live X Data for the xAI API
- 02The X Developer Portal (X Developer Console) for the Twitter (X) API: Sign-Up, Apps and Keys, Billing, Limits, and When You Do Not Need It
- 03SKILL.md explained: the Agent Skills format, X's own skill, and a Twitter (X) API skill you can install
- 04Twitter (X) Auto Post: Schedule in X, RSS or Sheets to X, and Posting from Code
- 05How to Search and Track Mentions on Twitter (X), Including Someone Else's
- 06Grok Agent: How to Build an Agent with Grok on Live Twitter (X) Data
- 07What Are Twitter (X) Bots and How Do They Work in 2026?
- 08Twitter Search Engine Optimization: How X Search and Google Rank Your Posts
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API key