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

By TwitterAPI.io Team•19 min read
Dark timeline of nine official X API changes verified on docs.x.com/changelog: free access ends (paid Basic tier) in February 2023; follows endpoints removed from Basic and Pro in June 2023; like and follow endpoints removed from the Free tier in August 2025; pay-per-use pilot at $0.005 per post read in October 2025; pay-per-use launch in February 2026; programmatic replies restricted to summoned replies in February 2026; Owned Reads at $0.001 in April 2026; new search index with min_likes back in May 2026; $20 plus up to $50 free credits in October 2026. Footer: official rate card $0.005 per post read = $5.00 per 1,000 posts versus twitterapi.io 15 credits per tweet returned = $0.15 per 1,000, about 33x less; @XDevelopers posted about 7.3 announcements a month in the 2026 sample.
The X API changes that moved prices, tiers and endpoints, as listed on docs.x.com/changelog. The table below adds what each one costs now and whether a third-party API user is affected.

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.

01 — Section

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.

OperationOfficial pay-per-use rate cardPer 1,000
Post, List, Space, Community, Note or Profile-update read$0.005 per resource$5.00
User, DM event, following or follower read$0.010 per resource$10.00
Like, mute or block read$0.001 per resource$1.00
Owned Reads (your own data, qualifying endpoints)$0.001 per resource$1.00
Post create / post create with a URL / summoned reply$0.015 / $0.200 / $0.010 per request
DM interaction or user interaction create / interaction delete$0.015 / $0.010 per request

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.

02 — Section

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.

WhenWhat changed (official wording)What it costs or allows nowThird-party API user
October 2, 2026"Pay-per-use accounts can now earn free X API credits two ways: a one-time $20 when an account saves its first eligible payment card, and a one-time match of the first successful auto-recharge, up to $50."up to $70 of official credits, card requiredUnaffected. twitterapi.io sign-up gives up to $1 of free credits (at most 100,000) with no card to new accounts that pass the automatic bot check, one per person or network, expiring after 31 days.
September 2026Livestream API rebuilt; 23 new X Chat endpoints in X API v2.169 (announced by @XDevelopers on September 22 and 30)new write surfaces on pay-per-useUnaffected for reads. twitterapi.io does not expose livestream or X Chat management.
July 30, 2026X Chat API and Chat XDK launched, "Free on pay-per-use (limited time), up to 500 msgs/day" (@XDevelopers)a quota, not a price, for nowUnaffected. DMs on twitterapi.io go through an authenticated session (/twitter/send_dm_to_user, $0.002 per call) and act as that account.
July 8, 2026Mention events available in the X Activity API and X API pay-per-use (@XDevelopers)sub-second mention events on pay-per-useComparable: /twitter/user/mentions costs 15 credits per tweet returned; a filter rule on /oapi/tweet_filter/add_rule pushes matches to your webhook.
May 4, 2026"The X API v2 search endpoints migrated to the new X core platform search index ... three new precision operators: min_likes:, min_replies:, and min_reposts:."the operators deprecated in January are backUnaffected. /twitter/tweet/advanced_search accepts X's search operators such as min_faves: and min_retweets:.
April 16, 2026"Effective April 20, 2026, new 'Owned Reads' pricing at $0.001 per resource (1,000 for $1) applies for qualifying endpoints when accessing your own data."$0.001 per owned resource; other reads unchanged at $0.005Unaffected. twitterapi.io prices a read the same whether or not the data is yours: $0.15 per 1,000 tweets returned.
March 20, 2026Account Activity replay endpoint deprecated in favor of POST /2/webhooks/replaymigration work for Account Activity usersUnaffected.
February 23, 2026"Programmatic replies via POST /2/tweets are now only permitted when the original Post's author has 'summoned' the replier. These changes affect self-serve tiers only."a summoned reply is $0.010 per requestAffects anyone posting replies through any route: a reply sent with /twitter/create_tweet_v2 acts as that account, and X applies its platform rules to the account, so keep a human pace.
February 6, 2026"Launch of X API Pay-Per-Use pricing ... Developers buy credits upfront and are charged per request, no fixed subscription fees." New Developer Console at console.x.com, XDK for Python and TypeScript.$0.005 per post read, $0.010 per user read, $0.015 per post created ($0.20 with a URL)Unaffected. The same 1,000 posts are $5.00 there and $0.15 per 1,000 tweets returned here.
January 19, 2026"The min_likes, min_replies, and min_reposts operators on /2/tweets/search/recent and /2/tweets/search/all have been deprecated."reversed on May 4, 2026Unaffected.
December 2025X API Playground for local development without real calls (December 23); official Python and TypeScript XDKs (November 3); News endpoints (November 19)tooling, no price changeUnaffected.
October 20, 2025"X API Pay-Per-Use pricing pilot ... Initial pilot rates: $0.005/Post Read, $0.01/User Read, $0.01/DM Event Read, $0.01/Content Create, $0.01/DM Interaction, $0.015/User Interaction." A limited closed program.the rate card that became public in February 2026Unaffected.
September 9, 2025"Launch of the Filtered Stream Webhooks API ... Available to Enterprise developers; supports 25,000+ rules per project."Enterprise onlyComparable without Enterprise: /oapi/tweet_filter/add_rule plus update_rule posts matches to a webhook you host, billed per check and per tweet.
August 22, 2025"We removed POST /2/users/:id/likes and POST /2/users/:id/following from the X API Free tier, effective immediately. Paid tiers remain unaffected."like and follow writes need a paid routeWrites on twitterapi.io run through an authenticated session: one /twitter/user_login_v2 login ($0.10, with a proxy you supply), then $0.002 per like or follow call, billed per HTTP 200 call, acting as that account.
September 28, 2023Reposts lookup launched in v2; v1.1 search endpoints deprecatedv2 only for searchUnaffected.
June 26, 2023"The Follows and List Follows endpoints were removed from the Basic and Pro tiers of the X API v2."follower lists need Enterprise on the official sideUnaffected: /twitter/user/followers and /twitter/user/followings return about 200 users a page at 1 to 3 credits per user, no X account needed.
February 2, 2023@TwitterDev (reposted by @API): "Starting February 9, we will no longer support free access to the Twitter API, both v2 and v1.1. A paid basic tier will be ..." The most reposted item in our @API sample (18,947 reposts).the end of the free API; tiers followed on March 29, 2023 and a Pro tier on May 25, 2023The moment most third-party X APIs date from.

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.

03 — Section

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.

Topic (keyword rule)PostsShareMedian likesMedian views
New endpoint / feature7135.5%13627,847
Other4924.5%13320,862
Pricing / billing4221.0%28851,799
Events / community2713.5%11430,798
Policy / terms73.5%22331,119
Rate limits / quotas31.5%296121,821
Deprecation / retirement10.5%13487,046

Likes and views of a repost are those of the original post. Groups under 10 posts are indicative only.

Stacked bar chart of @XDevelopers posts per month over 17 full months, colored by topic under the keyword rule: pricing and billing in orange, new endpoint or feature in blue, policy in purple, rate limits in teal, deprecation in gold, events in light blue, other in gray. Monthly totals run 7, 6, 11, 6, 16, 12, 15, 4, 16, 3, 21, 7, 12, 19, 19, 13 and 10, with a dashed line at the median of 12 posts a month. The busiest month, 21 posts, is the month Owned Reads pricing was announced; the quietest, 3, is the month after the pay-per-use launch.
@XDevelopers posts per month by topic, 200 most recent posts collected in 2026. Median 12 posts a month; 21% of all posts touch pricing or billing.
04 — Section

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.

Two horizontal bar panels for @XDevelopers posts by topic. Left, share of posts: new endpoint or feature 35.5%, other 24.5%, pricing and billing 21.0%, events and community 13.5%, policy 3.5%, rate limits 1.5%, deprecation 0.5%. Right, median likes per post: rate limits 296, pricing and billing 288, policy 223, new endpoint or feature 136, deprecation 134, other 133, events 114. Pricing posts are a fifth of the sample but draw about twice the likes of a feature post.
Topic share (left) versus median likes per post (right), 200 posts from @XDevelopers collected in 2026. Groups under 10 posts are indicative only.
05 — Section

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).

Read or actionOfficial pay-per-use rate cardtwitterapi.io
1,000 posts (search, timeline, mentions, replies, quotes)$5.00 ($0.005 per post read)$0.15 (15 credits per tweet returned; $0.003 per full 20-tweet page; $0.00015 minimum per request)
1,000 user profiles$10.00 ($0.010 per user read)$0.18 (18 credits per profile)
1,000 followers or followings$10.00 ($0.010 per follower read)$0.01 to $0.03 (1 to 3 credits per user returned, per-page tiers)
An empty poll (nothing new)one request, billed per resource returned$0.00015 minimum; every 60 seconds for a month is $6.48, every 5 minutes $1.30
Monthly ceiling3 million post reads, then Enterprisenone; purchased credits never expire
Free credits$20 on a first saved card and purchase, plus a match of the first auto-recharge up to $50$1 (100,000 credits), no card, for new accounts that pass the automatic bot check; one per person or network (others $0.10); expires after 31 days
Rate limitper endpoint, 15-minute windows (for example 450 per 15 minutes per app on recent search)0.2 requests per second before the first payment, 20 once paid, 50 on Scale, 500 on Business, up to 1,000 on request
Posting, liking, following, DMs$0.015 per post created ($0.20 with a URL), $0.015 per user interaction, summoned reply $0.010$0.10 for one /twitter/user_login_v2 login (with a proxy you supply) that returns login_cookies, then $0.002 per /twitter/create_tweet_v2, like, follow or DM call, billed per HTTP 200 call; the call acts as that account, which X can rate-limit, lock or suspend, so keep a human pace and expect to re-login occasionally

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.

06 — Section

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.

07 — Section

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.

08 — Section

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.

python
"""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()
09 — Questions

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.

10 — Further reading

Continue

Sources & further reading
More from this series
Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key