Is the Twitter API Free in 2026? What Happened to the Free Tier

Ask whether the Twitter API is free and the honest reply is short, and misreading it is where a lot of developers burn an afternoon. There is no free tier in 2026 on what is now officially the X API, though "Twitter API" still owns the search demand. Every call bills: a post read is $0.005, a user lookup $0.010, a plain post $0.015. The free tier that ran from 2023 into early 2026 only ever wrote, up to 1,500 posts a month, and read nothing at all. No search, no timelines, no profile lookups, no follower lists, no engagement numbers. If you arrived here meaning to fetch tweets for a dashboard, a sentiment model, or a research corpus, there is no free official route, and no setting buried in the console that flips one on.

TL;DR: The X API has no free tier and no subscriptions in 2026: every read and every post bills on pay-per-use, per X's developer pricing pages. Reading costs $0.005 per post read and $0.010 per user lookup, and a plain post is $0.015. The old free tier wrote only, 1,500 posts a month, and Basic and Pro closed to new signups in February 2026. Cheapest reads run through a third-party API like TwitterAPIs at $0.0008 a call, about $0.04 per 1,000 tweets on a full 20-tweet page, per its pricing page.

The old free tier in one picture: post yes, read no

None of this confusion is on you, it is baked into the history. For most of the API's existence "free tier" meant "read for free, within rate limits," and every tutorial older than a few years still tells that story. February 2023 ended it. The label "free tier" survived three more years as a posting-only allowance, and then pay-per-use removed it too: every read and every write is now metered. This guide lays out the entire 2026 cost ladder, unpacks the pay-per-use model that replaced the subscriptions, runs the real cost-per-1,000-tweets numbers, and marks the point where a third-party read API becomes the sensible move once the official per-call rate stalls you.

jamie paige lyrics!

@jamiepaigebot

⚠️ bad news :( a couple months ago, twitter - sorry, "X" - retired its old API pricing and forced everyone onto a new pay-per-use model, which no longer has any kind of free tier. they gave $10 in API credits to existing applications, but that ran out earlier this month.

468 likes6 replies

Open on X

How "Free" Stopped Meaning "Free Reads"

The free tier was not always a posting-only tool, and tracing how it narrowed and then disappeared explains why 2026 feels so cramped, and why so many teams got blindsided by the migration.

Between 2006 and early 2023, the public API read freely inside rate limits. Then in February 2023 X stripped out free read access and stood up paid subscription tiers, a move the platform's developer account announced directly and that drew a loud reaction at the time. Basic, at $200 a month, came with 15,000 reads. Pro, at $5,000 a month, came with a million, per X's developer pricing. Those two tiers carried read workloads for the next three years. In February 2026 X closed them to new signups and started shifting existing subscribers onto pay-per-use, which is how a project happily running on Basic in January woke up on per-call billing by spring.

For anyone who lived on a legacy tier, the migration rewrites the budget. A job that read 100,000 tweets a month inside a flat $200 Basic plan now bills $500 at the $0.005 pay-per-use rate (X API pricing), because the bundled quota is gone and every read meters on its own. The official migration notices sit on the developer pricing pages, and outside references like the DataForSEO migration guide map how the old quotas translate into per-call spend. For the same comparison against a direct API, the Twitter API cost breakdown and the best Twitter API for scraping post show what that volume costs elsewhere.

Two decades of access, from open reads to metered credits

Exactly What the Old Free Tier Let You Do

The free tier sat at the bottom of the access ladder, and it existed for one job: letting a developer or a hobby bot post to X at no cost. It is gone now, since pay-per-use carries no free allowance, but its shape explains most of the confusion still online.

You got write access to the v2 POST /tweets endpoint with a ceiling of 1,500 posts a month, per X's access levels. That was plenty for a scheduling bot, an auto-publisher, a status-page poster, or a side project that pushed updates onto a timeline. Bundled alongside it were the account-management calls the posting app depended on, and nothing more. On pay-per-use the same posts bill $0.015 each. If you are wiring up that kind of automation, the how to build a Twitter bot guide walks the posting loop end to end.

What never appeared was the entire read half of the API. Search returned nothing. So did timeline reads, profile lookups, follower and following lists, DM reads, and every engagement-data endpoint. Each of those is a read, and reads were simply absent from the free tier at any volume. The cap was not "1,500 of anything you like," it was "1,500 writes and exactly zero reads."

Reads, writes, and search at a glance across the old and current tiers

Three details caught people out. First, 1,500 counted posts you publish, not tweets you can pull. Second, the free tier still demanded an approved developer account, a genuine review and not an instant on switch. Third, because the tier sat at the floor of the access hierarchy, any endpoint that required a higher level answered with a 403 no matter how cleanly you format the request. The official definitions of each access level live in the X API access levels overview, which is the authoritative reference for what shifts between tiers.

The Read Paywall: Why Search Returns 403

There is no free read access on the official X API in 2026. Not at any tier, not at any volume. Every GET against a search, timeline, lookup, or follower endpoint needs pay-per-use credits. The subscriptions that once bundled reads are retired.

It is worth saying flatly, because this is the real question hiding inside the search. "Is the Twitter API free" almost always means "can I read tweets for free." No. There is no free tier, pay-per-use meters every read, and the subscriptions that once bundled reads are retired. One door remains for reading a tweet through the official API: pay per call on pay-per-use.

Three near-free paths exist, and naming them keeps you from chasing the wrong one.

1. The signup trial credit. A fresh official developer account gets a small voucher (approximately $0.10 today) once payment setup completes. That is roughly 20 reads, enough to confirm your integration responds and nothing more.
2. The Academic Research product. X runs a separate API for vetted researchers at accredited institutions, non-commercial only, behind a long application queue. If you qualify it is the one read path not strictly metered per call, but it is closed to ordinary developers.
3. Third-party read APIs with signup credits. Providers outside X hand you credits to trial their read endpoints. Once the credit runs dry it is pay per call, never free forever.

If your real query was "twitter api for free to read tweets," doors one and two will not ship a project, and door three is the only one that puts working read code in your hands without a card on file.

The Full 2026 Price Ladder

The live X API model is consumption-based: prepay credits, pay per call, no fixed monthly floor and no free tier. The subscriptions that defined 2023 through early 2026 are retired. The table below is the single canonical view of every official tier, current and retired, checked in September 2026 against X's developer pricing pages.

Tier	Availability	Price / month	Reads	Writes	Detail
Free (2023 to early 2026)	Retired	$0	None	1,500 monthly	Posting only; no free tier exists today
Pay-per-use	Open (default)	Metered	$0.001 to $0.005 each	$0.015 per post, $0.200 if it carries a URL	No floor, 3M-read monthly ceiling
Basic	Retired (closed Feb 2026)	$200	15,000 monthly	50,000 monthly	Remaining subscribers moved to pay-per-use from 1 June 2026
Pro	Retired (closed Feb 2026)	$5,000	1,000,000 monthly	300,000 monthly	No longer sold
Enterprise	Open	No published price	Custom	Custom	Forced past 3M reads, and for follow/like after April 2026

Three numbers carry the weight, per X's developer pricing. There is no free tier. Pay-per-use has no entry fee but meters every call. Enterprise carries no published price and is the forced landing spot for anyone past 3 million reads in a billing cycle, because X answers that volume with a contact form rather than a rate card. Basic and Pro are retired and no longer sold, so treat them as history when you plan.

Two date-stamped changes set the current shape. February 2026 retired Basic, Pro, and the self-serve Enterprise tiers for new signups and moved everyone to pay-per-use credits, a shift carried through to the April 2026 pricing update on the X developer pages. April 2026 then raised a URL-bearing post from $0.010 to $0.200 (X API pricing) to slow automated link spreading, and moved following, liking, and quote-posting to Enterprise-only access. The full history and the per-call effect of each change live in the Twitter API cost breakdown, while the Twitter API tutorial covers building against the new model end to end, and the 2026 X API pricing change log tracks each dated shift on its own.

r/

r/Twitter·u/aleks__under

X/Twitter api free tier?

00

Open on Reddit

Pay-Per-Use, Operation by Operation

Pay-per-use is the model every new developer meets first in 2026. Rather than a monthly subscription with a bundled quota, you hold a credit balance and each call subtracts its own per-operation price. Hit zero and calls pause until you top up. No monthly floor, no contract.

The per-operation rate card below was verified June 2026 against the X developer pricing pages.

Operation	Per-call price	What it covers
Owned-account read	$0.001	Pulling resources from your own account
Read a post by ID	$0.005	One tweet object, expansions and all, is a single read
Search recent posts	$0.005 each result	A 100-result query meters as 100 reads
User profile lookup	$0.010	Includes the follower and following counts
Plain-text post create	$0.015	A standard write
Link post create	$0.200	The April 2026 anti-spam surcharge on URL posts

The hard ceiling is 3 million post reads a monthly billing cycle. Cross it and the account must move to Enterprise, which X does not publish a price for and which runs through its sales team. For most read-led projects the per-call rate bites long before the ceiling does, because the totals climb fast: at the official $0.005 per read rate, 100,000 reads is $500 and a million is $5,000, all well short of the cap.

The read surfaces a write-only token never reached

When you forecast spend, size the read volume first, because reads dominate nearly every data project. The pay-per-use pricing model page and the Twitter API pricing page show how the per-call costs land on mixed workloads, and the rate limits guide covers the per-endpoint windows that still apply on top of per-call billing.

Running the Numbers: Cost to Pull 1,000 Tweets

This is the calculation the "is it free" question is really after. Below is what reading tweets costs across the official API and the main third-party providers, at four common volumes. Most ranked pages skip exactly this comparison.

Volume	TwitterAPIs	twitterapi.io	Apify (est)	Official X pay-per-use
1,000 tweets	$0.04	$0.15	$0.25 to $0.40	$5.00
10,000 tweets	$0.40	$1.50	$2.50 to $4.00	$50.00
100,000 tweets	$4.00	$15.00	$25.00 to $40.00	$500.00
1,000,000 tweets	$40.00	$150.00	est $250 to $400	$5,000.00

The official rate is $0.005 per standard post read, per X's developer pricing pages. TwitterAPIs meters reads at $0.0008 per call, roughly $0.04 per 1,000 tweets at typical batch sizes since a single call returns about 20 tweets, per the TwitterAPIs pricing page. The $0.15 per 1,000 for twitterapi.io comes from its published per-call rate, and the Apify band is a model based on its per-actor-event billing, which moves by actor, so read it as a range rather than a fixed figure. Treat the competitor numbers as illustrative and check each against the vendor's own pricing page, those links are not endorsements: twitterapi.io and Apify. For the wider field, the cheapest Twitter API providers ranked by real per-1,000-tweet cost breakdown and the Twitter API cost benchmark put each provider on the same yardstick.

What 1,000 reads runs you, provider by provider

The story is the roughly hundred-fold gap between the official rate and the direct-API rate. At a million tweets the official API bills $5,000 (X API pricing) while a direct API bills about $40. That spread is the whole reason "is the Twitter API free" keeps getting typed: people see the official sticker price, assume a free door must exist somewhere, and the honest answer is that the cheapest real option is a paid third-party read API, not free anything. To size your own blend of reads, writes, and lookups, push the figures through the cost calculator.

Where the Free Path Falls Apart

The old free tier nailed exactly one category: posting. Bots, schedulers, and auto-publishers that only wrote tweets lived inside the 1,500-a-month cap without spending a cent. On pay-per-use even that is metered, at $0.015 a post and $0.200 for a post carrying a URL. Everything that reads data hits a wall of per-call charges.

This is the line that decides what the official API costs you.

• Cheap on the official API: posting bots, content schedulers, status-update publishers, anything that creates tweets and never reads them, at $0.015 a post.
• Expensive on the official API: sentiment analysis, social listening, brand monitoring, market research, lead generation, follower-graph analysis, viral detection, KOL tracking, and any analytics that leans on reading public data.

The data jobs that hit a wall on a posting-only key

The trap repeats with grim reliability. You sign up expecting a free sandbox, fire a GET at /2/tweets/search/recent as your very first call, and learn that search is a paid read endpoint. On the old free tier that first call came back 403 Forbidden, the most common free-tier shock there was, and it is why the question still fills threads in r/webdev and r/Twitter. If your project reads data, there is no official free path, and the real choice is pay-per-use or a third-party API. For production read pipelines, the scraping best practices guide and the Python Twitter API tutorial cover staying inside rate limits and budget.

The route from signup to the 403 nobody warned you about

Solar Marine

@SolarMarineX

Since February, X has been charging 0.01$ for every post created via API by Solar Marine, as they introduced a new pay-per-use pricing. Even though every notification by Solar Marine incurred cost it was low and we didn't have to worry about very low limit on free tier.

3 likes1 replies

Open on X

Going Around the Official API: Direct Read Providers

When the official API has no free tier and the official paid read is $0.005 a call (X API pricing), developers reach for a third-party API. These services expose the same public tweet data behind one REST surface, priced per call, with no X developer account in the loop.

The differences from the official path are concrete. No application review, because you never create an X developer app. No subscription, because billing is per call. No platform read cap shoving you toward Enterprise, because your only ceiling is the credit balance. And setup runs in minutes instead of days: register with an email, copy a Bearer token, make a call.

Signup credits are how most providers let you kick the tires before committing. TwitterAPIs hands over $0.50 in credit with no card, around 625 calls or roughly 12,500 tweets through the read endpoints. Apify grants a small monthly free allowance and then meters per actor event, which is harder to forecast. None of them offer unlimited free reads, every one is pay-per-call or pay-per-actor once the credit empties. TwitterAPIs spans 112 endpoints in total, 68 on the read side (including the tweet and thread endpoints) and 44 write endpoints, so it is not a read-only tool.

Here is the recent-search query the old free tier refused to run, pointed at a direct API. The request was executed live against the TwitterAPIs search endpoint before this post went out.

import os
import httpx

TOKEN = os.environ["TWITTERAPIS_KEY"]


def fetch_latest(term: str, limit: int = 5):
    """Pull the most recent matches for a search term."""
    res = httpx.get(
        "https://api.twitterapis.com/twitter/tweet/advanced_search",
        params={"query": term, "product": "Latest"},
        headers={"Authorization": f"Bearer {TOKEN}"},
        timeout=30,
    )
    res.raise_for_status()
    data = res.json()
    print("hits:", data["count"])
    return data["tweets"][:limit]


for tweet in fetch_latest("brand sentiment x api"):
    handle = tweet["author"]["username"]
    print(tweet["created_at"], f"@{handle}", tweet["text"][:70])

The same lookup in curl, for a fast terminal check:

curl -s "https://api.twitterapis.com/twitter/tweet/advanced_search?query=developer%20tooling&product=Latest" \
  -H "Authorization: Bearer $TWITTERAPIS_KEY"

And in Node.js, for a JavaScript stack:

const KEY = process.env.TWITTERAPIS_KEY;

async function searchLatest(term) {
  const qs = new URLSearchParams({ query: term, product: "Latest" });
  const res = await fetch(
    `https://api.twitterapis.com/twitter/tweet/advanced_search?${qs}`,
    { headers: { Authorization: `Bearer ${KEY}` } }
  );
  if (!res.ok) throw new Error(`request failed: ${res.status}`);
  return res.json();
}

const data = await searchLatest("developer tooling");
console.log("hits:", data.count);

Reads are half the story. The 44 write actions (favorite and unfavorite, retweet and unretweet, bookmark and unbookmark, follow and unfollow, delete, tweet creation, media upload, and DM send) take your own session credentials per request and never store them, so the action runs as your account rather than a shared bot pool. DM send is in the set as well. A favorite call looks like this:

# write actions carry your own auth_token + ct0 per request, never stored
import os
import httpx

httpx.post(
    "https://api.twitterapis.com/twitter/tweet/favorite",
    json={
        "tweet_id": "1899999999999999999",
        "auth_token": os.environ["X_AUTH_TOKEN"],
        "ct0": os.environ["X_CT0"],
    },
    headers={"Authorization": f"Bearer {os.environ['TWITTERAPIS_KEY']}"},
)

Because the credentials ride on the request rather than living in the provider, a write action runs as the real account and there is no shared pool to land you in someone else's rate-limit trouble. That session-scoped model covers posting, the engagement and follow actions, and DM send alike, so anyone who needs messaging runs it on the same key at $0.0016 per call instead of reaching for the official API.

No project, no app, no payment method for the trial credit. A direct read API earns its place on research projects, indie apps, high-volume read jobs, and anywhere the official $0.005-per-read rate is the bottleneck. For a head-to-head on the providers, see the TwitterAPIs vs twitterapi.io comparison and the migrating from twitterapi.io guide. The Apify Twitter scraper vs TwitterAPIs post digs into the per-actor billing tradeoff, and the RapidAPI Twitter alternative breakdown covers marketplace listings.

The Developer-Account Gate

Yes. There is no free tier, and even pay-per-use needs an approved developer account on developer.x.com. That surprises anyone who reads "free" as "instant," and the gap between signing up and landing your first call can run into days.

The flow is a real review. You open an account, create a Project, build an App inside it, describe the use case, and accept the developer terms. X reviews the submission, and the review tightens for automation, bots, and research, which are precisely the things developers want the API for. Rejections happen, and reapplying with a sharper use-case description is routine.

# Once X approves your app and credits are loaded, a plain post bills $0.015
curl -X POST "https://api.x.com/2/tweets" \
  -H "Authorization: Bearer $X_BEARER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"text": "first post from the API"}'

That POST was the one move the old free tier reliably made. On pay-per-use it bills per post, and every GET read endpoint bills too, from $0.005 a post. Credential generation, the common rejection patterns, and the faster alternative path are all in the how to get a Twitter API key walkthrough and on the Twitter API key page.

The alternative skips the account entirely. Third-party read APIs need no X developer account, because they are not X. You register directly, copy a key, and call. For read-led work that removes the slowest and least predictable step in the whole chain, waiting on X to approve you.

I Made Twitter API Free

— FaceDev, walking through the post-pricing-change reality on YouTube

https://www.youtube.com/watch?v=kz8-puGf2nY

Reading the Errors: 403, 429, and the Headers That Matter

Even a funded pay-per-use token runs into rate limits, and they are easy to trip if you ignore the response headers. POST /tweets carries a per-15-minute request window on top of the per-post charge. Break it and you get a 429 carrying a reset timestamp.

The error you actually meet first, though, is the 403 Forbidden on reads, the status that means your credentials are valid but the resource is out of bounds for your access level. Here is a clean way to branch on it so your code fails with a useful message rather than a raw stack trace:

import os
import requests


def try_search(term):
    res = requests.get(
        "https://api.x.com/2/tweets/search/recent",
        params={"query": term, "max_results": 10},
        headers={"Authorization": f"Bearer {os.environ['X_BEARER_TOKEN']}"},
    )
    match res.status_code:
        case 403:
            return "blocked: no read access on this app, search is pay-per-use"
        case 429:
            return f"throttled until unix {res.headers.get('x-rate-limit-reset')}"
        case _:
            res.raise_for_status()
            return f"{res.json()['meta']['result_count']} results"


print(try_search("electric vehicles"))

Three headers govern every official call: x-rate-limit-limit, x-rate-limit-remaining, and x-rate-limit-reset, documented in the X API rate limits reference. Overrun a window and you get a 429 Too Many Requests, so check x-rate-limit-remaining on each response, back off as it nears zero, and honor the reset timestamp. The auth header patterns behind these calls are in the X API authentication overview, and the user-context write flow builds on the OAuth 2.0 framework with PKCE per RFC 7636. For Python against the official API, most teams reach for the community library Tweepy, which wraps the auth and rate-limit plumbing.

You can also read which model your own token sits on straight from the headers:

# The response headers reveal which billing model your token is on
curl -sI "https://api.x.com/2/tweets/search/recent?query=test&max_results=10" \
  -H "Authorization: Bearer $X_BEARER_TOKEN" | grep -i "x-rate-limit\|x-access-level"

The x-access-level header tells you what access the token holds. If reads come back 403 and the access level shows write-only, the app has no read access, and reading anything means pay-per-use credits.

On a third-party read API the rate-limit picture is simpler: no per-window read ceiling, only your credit balance, so the 403-on-access and 429-on-window headaches both vanish. You still want exponential backoff for transient network errors, but you are no longer fighting tier gates. The advanced search operators guide and the Twitter API v2 vs TwitterAPIs comparison show how the read endpoints behave once those gates are out of the way.

Picking a Tier for Your Project

It all reduces to one question: do you read data, or only write it? Write only, and the official API bills $0.015 a post, with no free allowance underneath. Read anything, and you are paying more, the only open question is whom.

Your goal	Where it belongs
Publish from a bot or scheduler	Pay-per-use, $0.015 a post, $0.200 with a URL
Read a handful of public tweets	Pay-per-use or a direct read API
Run search queries in code	Direct API (official search bills $0.005 a result)
Grab follower or following lists	Direct API (the official path is metered)
Score sentiment at scale	Direct API (100K reads is $4, not $500)
Stand up live monitoring	Direct API, with no rate-window ceiling
Map a rival's follower graph	Direct API

Match your job to the path that costs least

The table reads one way: light writes sit fine on pay-per-use, reads belong wherever they cost least, which at scale is a direct API. The gap is not marginal. At a million reads the official API is $5,000 and a direct API is about $40, the same data for under one percent of the price.

One million reads, direct API against the official rate

That spread holds at every rung, not just the headline million. Whether you read fifty thousand tweets a month or two million, the per-call distance between the official rate and a direct API stays at about the same multiple, which is why the curve below matters more than any single point.

How the spend curve holds across 50K, 500K, and 2M reads

To narrow it for your own build, map the read and write split. A low-volume posting bot stays cheap on pay-per-use. A read pipeline at any real volume is cheaper on a direct API, and you can pin the exact figures with the cost calculator and the Twitter API alternatives comparison. For sentiment, the Twitter sentiment analysis tutorial walks the read pipeline end to end, and for follower data the export Twitter followers guide covers the lookup endpoints. The Twitter trends API guide rounds out the read endpoints the old free tier never exposed.

r/

r/programming·u/Sophira

@TwitterDev: "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 available instead"

00

Open on Reddit

The Bottom Line

So, is the Twitter API free? No. The official X API has no free tier and no subscriptions in 2026, and the old write-only tier, 1,500 posts a month and zero reads, is gone. Every post bills from $0.015, and reading costs on every route, $0.005 per standard read on pay-per-use (X API pricing), or about $0.04 per 1,000 tweets through a third-party read API, per our pricing page. Basic and Pro shut to new signups in February 2026, and the April 2026 update pushed URL-posts and several write actions higher still.

The practical call: if you only post at low volume, pay-per-use at $0.015 a post keeps the bill small. If you read data, use pay-per-use when you are already wired into X's platform, or a third-party read API when you want reads without a subscription, a developer-account review, or the $0.005-per-read rate. Either way, "free" no longer describes any official X API tier. Start with the pricing page for the per-call rates, model your volume with the cost calculator, and grab $0.50 in free credits with no card on the signup page.