Is the Twitter API Free in 2026? What the Free Tier Actually Gives You

Ask whether the Twitter API is free and the honest reply splits in two, and that split is where a lot of developers burn an afternoon. There is a free tier in 2026 on what is now officially the X API, though "Twitter API" still owns the search demand. The catch is direction: the free tier only writes. You can publish as many as 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, the free tier will not do it, and there is no setting buried in the console that flips it on.

TL;DR: The X API free tier writes only: 1,500 posts a month, zero reads, per X's published access levels. Reading costs $0.005 per post read and $0.010 per user lookup on pay-per-use, per X's developer pricing pages. Basic and Pro closed to new signups in February 2026. Cheapest reads run through a third-party API like TwitterAPIs at about $0.04 per 1,000 tweets, per its pricing page.

The 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, but its meaning flipped inside out: free now pays for writes, and reads became a metered product. 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 free tier stalls you.

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

— @jamiepaigebot view on X

How "Free" Stopped Meaning "Free Reads"

The free tier was not always a posting-only tool, and tracing how it narrowed explains why the 2026 version 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 Free Tier Lets You Do

The free tier sits at the bottom of the access ladder, and it exists for one job: letting a developer or a hobby bot post to X at no cost. Here is its precise shape as of June 2026.

You get write access to the v2 POST /tweets endpoint with a ceiling of 1,500 posts a month, per X's published access levels. That is plenty for a scheduling bot, an auto-publisher, a status-page poster, or a side project that pushes updates onto a timeline. Bundled alongside it are the account-management calls the posting app depends on, and nothing more. 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 appears is the entire read half of the API. Search returns nothing. So do timeline reads, profile lookups, follower and following lists, DM reads, and every engagement-data endpoint. Each of those is a read, and reads are simply absent from the free tier at any volume. The cap is not "1,500 of anything you like," it is "1,500 writes and exactly zero reads."

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

Three details catch people out. First, 1,500 counts posts you publish, not tweets you can pull. Second, the free tier still demands an approved developer account, a genuine review and not an instant on switch. Third, because the tier sits at the floor of the access hierarchy, any endpoint that requires a higher level answers 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 either pay-per-use credits or a legacy subscription that stopped taking new accounts in February 2026.

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. The free tier reads nothing, pay-per-use meters every read, and the subscriptions that once bundled reads are shut to newcomers. Two doors remain for reading a tweet through the official API: pay per call on pay-per-use, or already hold a legacy subscription.

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 above the free tier. The subscriptions that defined 2023 through early 2026 are now legacy and closed to new buyers. The table below is the single canonical view of every official tier as of June 2026, verified against X's developer pricing pages.

Tier	Availability	Price / month	Reads	Writes	Detail
Free	Open	$0	None	1,500 monthly	Posting only, approved dev account needed
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, 2M-read monthly ceiling
Basic	New signups closed Feb 2026	$200	15,000 monthly	50,000 monthly	Existing subscribers only
Pro	New signups closed Feb 2026	$5,000	1,000,000 monthly	300,000 monthly	Existing subscribers only
Enterprise	Open	Tens of thousands and up	Custom	Custom	Forced past 2M reads, and for follow/like after April 2026

Three numbers carry the weight, per X's developer pricing. The free tier is $0 and reads nothing. Pay-per-use has no entry fee but meters every call. Enterprise opens in the tens of thousands a month and is the forced landing spot for anyone past 2 million reads in a calendar month. Basic and Pro still run for accounts that subscribed before February 2026, but since no new developer can buy them, 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.

the r/Twitter thread asking what the X/Twitter API free tier actually includes from r/Twitter

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 2 million post reads a calendar month. Cross it and the account must move to Enterprise, which opens in the tens of thousands a month and runs through X's 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 reaches

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 Tier Falls Apart

The free tier nails exactly one category: posting. Bots, schedulers, and auto-publishers that only write tweets live inside the 1,500-a-month cap without spending a cent. Everything that reads data hits a wall.

This is the line that decides whether the free tier fits you.

• Free tier fits: posting bots, content schedulers, status-update publishers, anything that creates tweets and never reads them.
• Free tier does not fit: 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 sandbox, fire a GET at /2/tweets/search/recent as your very first call, and get a 403 Forbidden. Nothing in the signup flow flags that search is a paid read endpoint. It is the most common free-tier shock there is, and it is why the question fills threads in r/webdev and r/Twitter. If your project reads data, the official free path simply ends, 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

Since February, X has been charging 0.01$ for every post created via API, as they introduced a new pay-per-use pricing.

— @SolarMarineX view on X

Going Around the Official API: Direct Read Providers

When the official free tier reads nothing 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 48 endpoints in total, 34 on the read side (including the tweet and thread endpoints) and 14 write endpoints, so it is not a read-only tool.

Here is the recent-search query the free tier refuses 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["createdAt"], 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 12 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, even the write-only free tier 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 free-tier app, this is the only call that works
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 free tier"}'

That POST is the one move the free tier reliably makes. Swap it for any GET read endpoint and the answer is a 403. 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 write-only token runs into rate limits, and they are easy to trip if you ignore the response headers. POST /tweets on the free tier caps at the 1,500-a-month write ceiling, counted on a rolling monthly basis, with a per-15-minute request window stacked on top. Break either 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 tier. 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: free tier reads nothing, 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 whether the token is on the free write tier, pay-per-use, or a legacy subscription. If reads come back 403 and the access level shows write-only, you are on free and need to upgrade to read anything.

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-free 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 free tier is genuinely free. Read anything, and you are paying, the only open question is whom.

Your goal	Where it belongs
Publish from a bot or scheduler	Free tier, write only, no charge
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: writes belong on the free tier, 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 posting bot stays free. 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 free tier never exposes.

the r/programming thread on X removing free API access from r/programming

The Bottom Line

So, is the Twitter API free? A free tier exists, but it writes only: 1,500 posts a month and zero reads. 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, settle on the free tier and pay nothing. 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" describes a writing tool, not a reading one. 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.