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

Yes and no, and the gap between those two answers is where most developers lose a day. The Twitter API (officially the X API, though "Twitter API" still carries the search volume) does have a free tier in 2026. That free tier is write only. It lets you post up to 1,500 tweets a month and read absolutely nothing. No search, no timelines, no user lookups, no follower lists, no engagement data. If you came here planning to pull tweets for a dashboard, a sentiment model, or a research dataset, the free tier does not do that, and no amount of console clicking will unlock it.

TL;DR: The X API free tier is write only: 1,500 posts per month, zero read access. Reading tweets costs money either way: $0.005 per standard post read, $0.010 per user lookup under pay-per-use, with a 2-million-read monthly cap before Enterprise pricing at $42,000+/month. The Basic and Pro subscription tiers closed to new signups in February 2026. For read-heavy work the cheapest path is a third-party read API like GetXAPI at roughly $0.05 per 1,000 tweets, with $0.10 in free credits and no developer account. The rest of this guide breaks down every tier and what it actually costs.

What the free tier actually gives you

The confusion is structural, not your fault. For most of the API's life "free tier" meant "free read access with rate limits," and every tutorial older than three years still describes it that way. That model died in February 2023. What replaced it kept the words "free tier" but inverted the meaning: free now buys writes, and reads are a paid product. This guide walks the full 2026 cost ladder, explains the pay-per-use model that replaced the old subscriptions, shows the real cost-per-1,000-tweets math, and lays out where third-party read APIs fit when the official free tier leaves you stuck.

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

What Does the X API Free Tier Include?

The free tier is the smallest of the access levels, and its single purpose is letting a developer or a hobby bot post to X without paying. Here is the exact shape of it as of June 2026.

You get write access to the v2 POST /tweets endpoint, capped at 1,500 posts per month. That is enough for a scheduling bot, an automated publisher, a status-page poster, or a personal project that pushes updates to a timeline. You also get the basic account-management calls needed to support posting from the app you create.

What you do not get is the entire read side of the API. The free tier returns nothing from search, from timeline reads, from user lookups, from follower or following lists, from DM reads, or from any engagement-data endpoint. Every one of those calls is a read, and reads are not part of the free tier at any volume. The cap is not "1,500 reads," it is "1,500 writes and zero reads."

Capability quick-look by access tier

A few practical notes that trip people up. The 1,500 number is posts you create, not tweets you can fetch. The free tier still requires an approved developer account, which is a real review process and not an instant signup. And the free tier sits at the bottom of the access ladder, so any endpoint marked as needing a higher access level returns a 403 regardless of how your request is formed. The official tier definitions and what each access level unlocks are documented in the X API access levels overview, which is the authoritative source for what changes between tiers.

Is the Twitter API Free for Reading Tweets? (The Short Answer)

No. The official X API has no free read access in 2026, at any tier, for any volume. Every GET request against a search, timeline, user lookup, or follower endpoint requires either pay-per-use credits or a legacy subscription that closed to new signups in February 2026.

This is worth stating bluntly because it is the question behind the question. When someone searches "is the Twitter API free," they almost always mean "can I read tweets for free." The answer is no. The free tier reads nothing. The pay-per-use model charges per read. The legacy subscription tiers that bundled reads are closed to new signups. The only ways to read a tweet through the official API are to pay per call under pay-per-use or to be an existing legacy subscriber.

There are three free-adjacent paths, and it helps to name them so you do not waste time chasing the wrong one.

1. The signup trial credit. New official developer accounts get a small credit voucher (currently $0.10) after completing payment setup. That covers about 20 reads. It exists to verify your integration works, not to run anything.
2. The Academic Research product. X maintains a separate API for verified researchers at accredited institutions, capped at non-commercial use with a long application queue. If you qualify, it is the only volume read access that is not strictly per-call billed, but it is not open to general developers.
3. Third-party read APIs with free credits. Providers outside X give you signup credits to evaluate their read endpoints. These are pay-per-call after the credit runs out, not free forever.

If your search was really "twitter api for free to read tweets," paths one and two will not ship your project, and path three is the only one that gives you working read code without a payment method on file.

X API Pricing in 2026: Free, Pay-Per-Use, and Legacy Tiers

The current X API pricing model is consumption-based. You prepay credits and pay per call, with no fixed monthly minimum above the free tier. The subscription tiers that defined 2023 through early 2026 are now legacy and closed to new buyers. This single comparison table is the canonical picture of every official tier as of June 2026.

Tier	Status	Monthly cost	Post reads	Post writes	Notes
Free	Active	$0	None	1,500 / month	Write only; developer account required
Pay-per-use	Active (default)	Usage-based	$0.001 to $0.005 / read	$0.015 / post ($0.200 if URL)	No minimum; 2M post-read monthly cap
Basic	Closed to new signups (Feb 2026)	$200 / month	15,000 / month	50,000 / month	Legacy subscribers only
Pro	Closed to new signups (Feb 2026)	$5,000 / month	1,000,000 / month	300,000 / month	Legacy subscribers only
Enterprise	Active	$42,000+ / month	Custom	Custom	Required above 2M reads and for following/liking post-April 2026

The numbers that matter most: the free tier costs $0 and reads nothing, pay-per-use has no entry fee but bills every call, and Enterprise starts at $42,000 a month and is the forced destination for anyone above 2 million reads in a calendar month. The legacy Basic and Pro tiers still exist for accounts that subscribed before February 2026, but a new developer cannot buy them, so they are historical for planning purposes.

Twitter API pricing timeline, 2006 to 2026

Two date-stamped changes shaped the current model. In February 2026, X retired the Basic, Pro, and Enterprise self-serve subscription tiers for new signups and moved to pay-per-use credits, a shift documented as of the April 2026 pricing update on the X developer pricing pages. In April 2026, the price of a post containing a URL jumped from $0.010 to $0.200 to discourage automated link spreading, and following, liking, and quote-posting moved to Enterprise-only access. The detailed history and the per-call effects of each change live in the Twitter API cost breakdown, and the broader Twitter API tutorial covers how to build against the new model end to end.

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

How the New Pay-Per-Use Model Works

Pay-per-use is the model every new developer learns against in 2026. Instead of a monthly subscription that bundles a quota, you buy a credit balance and each API call deducts its per-operation price. When the balance hits zero, calls stop until you top up. There is no monthly floor and no contract.

Here is the per-operation rate card, verified June 2026 against the X developer pricing pages.

Operation	Per-call price	Notes
Owned-account read	$0.001	Reading your own account's resources
Read a post by ID	$0.005	Each tweet object, including expansions, is one read
Search recent posts	$0.005 per result	A query returning 100 results is 100 reads
Look up a user profile	$0.010	Includes follower and following counts
Create a post (plain text)	$0.015	Standard post create
Create a post (with URL)	$0.200	April 2026 anti-spam pricing on link posts
Send a DM	$0.015	Both 1-to-1 and group DM segments billed per send

The hard ceiling on pay-per-use is 2 million post reads per calendar month. Cross that and your account must migrate to Enterprise pricing, which starts at $42,000 a month and is negotiated through X's sales team. For most read-heavy projects the per-call rate matters more than the ceiling, because the costs add up fast: 100,000 reads is $500, and 1 million reads is $5,000, well before anyone touches the cap.

Every read endpoint the free tier cannot touch

If you are forecasting spend, model the read volume first because reads dominate almost every data project. The pay-per-use pricing model page and the Twitter API pricing page lay out how the per-call costs apply to mixed workloads, and the rate limits guide covers the per-endpoint windows that still apply on top of the per-call billing.

What Does It Actually Cost to Read 1,000 Tweets?

This is the math the "is it free" question is really asking. Below is what reading tweets costs across the official API and the main third-party read providers, at four common volumes. This is the comparison most ranked pages skip.

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

The official rate is $0.005 per standard post read. GetXAPI prices reads at $0.001 per call, roughly $0.05 per 1,000 tweets given typical batch sizes. The twitterapi.io figure of $0.15 per 1,000 comes from its published per-call rate, and the Apify range is an estimate based on its per-actor-event billing, which varies by actor, so treat it as a band rather than a fixed price. Competitor numbers here are illustrative and should be checked against each vendor's current pricing page (those links are deliberately not endorsements: see twitterapi.io and Apify).

Cost to read 1,000 tweets across providers

The headline is the two-orders-of-magnitude gap between the official rate and the third-party rate. At 1 million tweets the official API charges $5,000 and a direct API charges $50. That difference is the entire reason "is the Twitter API free" gets asked: people see the official price and assume there must be a free option, and the honest answer is that the cheapest real option is a paid third-party read API, not a free anything. To model your specific mix of reads, writes, and lookups, run the numbers through the cost calculator.

When the Free Tier Is Not Enough: Read-Heavy Use Cases

The free tier serves exactly one category of work well: posting. Bots, schedulers, and automated publishers that only need to write tweets fit inside the 1,500-per-month write cap without paying a cent. For everything that reads data, the free tier is a dead end.

Here is the split that decides whether the free tier works for you.

• Free tier works: posting bots, content schedulers, status-update publishers, anything that only creates tweets and never reads them.
• Free tier does not work: sentiment analysis, social listening, brand monitoring, market research, lead generation, follower-graph analysis, viral detection, KOL tracking, and any analytics that depends on reading public data.

Read-heavy work the free tier cannot serve

The developer trap is predictable. You sign up expecting a sandbox, you write a GET request against /2/tweets/search/recent as your first call, and you get a 403 Forbidden. Nothing in the signup flow warns you that search is a paid read endpoint. This is the single most common free-tier surprise, and it is why threads about it fill r/webdev and r/Twitter. If your project reads data, there is no free official path, and the decision narrows to pay-per-use or a third-party API. For production read workloads, the scraping best practices guide and the Python Twitter API tutorial walk through how to build read pipelines that stay inside rate limits and budget.

Why developers get stuck on the free tier

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

Third-Party Twitter APIs: Pay-Per-Call With Free Credits at Signup

When the official free tier cannot read and the official paid rate is $0.005 a call, developers reach for a third-party read API. These services present the same public tweet data through a single REST surface, priced per call, with no X developer account required.

The differences from the official path are concrete. There is no application review, because you are not creating an X developer app. There is no subscription, because billing is per call. There is no platform-level read cap forcing an Enterprise migration, because the only limit is your credit balance. And setup is minutes instead of days: sign up with email, copy a Bearer token, make a call.

Free credits at signup are how most of these providers let you evaluate before committing. GetXAPI gives $0.10 in credits with no credit card, enough for roughly 2,000 tweets through the read endpoints. Apify offers a small monthly free allowance but bills per actor event afterward, which is harder to predict. No third-party service offers unlimited free reads, all of them are pay-per-call or pay-per-actor once the credit is spent.

Here is the same recent-search query against a direct API, which is the read the free tier refuses to serve. This request was executed live against the GetXAPI search endpoint before publishing.

import os
import requests

API_KEY = os.environ["GETXAPI_KEY"]

resp = requests.get(
    "https://api.getxapi.com/twitter/tweet/advanced_search",
    params={"q": "twitter api free tier", "queryType": "Latest"},
    headers={"Authorization": f"Bearer {API_KEY}"},
)
resp.raise_for_status()
payload = resp.json()

print("matched tweets:", payload["tweet_count"])
for t in payload["tweets"][:5]:
    print(t["createdAt"], "@" + t["author"]["userName"], t["text"][:70])

The same call in curl, for a quick terminal check:

curl -s "https://api.getxapi.com/twitter/tweet/advanced_search?q=x%20api%20pricing&queryType=Latest" \
  -H "Authorization: Bearer $GETXAPI_KEY"

And in Node.js, if your stack is JavaScript:

const API_KEY = process.env.GETXAPI_KEY;

const params = new URLSearchParams({
  q: "twitter api free tier",
  queryType: "Latest",
});

const res = await fetch(
  `https://api.getxapi.com/twitter/tweet/advanced_search?${params}`,
  { headers: { Authorization: `Bearer ${API_KEY}` } }
);

if (!res.ok) throw new Error(`HTTP ${res.status}`);
const payload = await res.json();
console.log("matched tweets:", payload.tweet_count);

No project, no app, no payment method needed for the trial credit. When a third-party read API makes sense: research projects, indie apps, high-volume read workloads, and anything where the official $0.005 per read is the bottleneck. For a head-to-head on the main providers, see the GetXAPI vs twitterapi.io comparison and the migrating from twitterapi.io guide. The Apify Twitter scraper vs GetXAPI post covers the per-actor billing tradeoff in detail, and the RapidAPI Twitter alternative breakdown covers marketplace listings.

Do You Need a Developer Account for the Free Tier?

Yes. Even the write-only free tier requires an approved developer account on developer.x.com. This surprises people who assume "free" means "instant," and the gap between signing up and making your first call can be days.

The flow is a real review process. You create an account, create a Project, create an App inside it, describe your use case, and accept the developer terms. X reviews the application, and the review is stricter for automation, bots, and research use cases, which are exactly the things developers want the API for. Rejections happen, and re-applying with a clearer use-case description is common.

# First write call once your free-tier app is approved
curl -X POST "https://api.x.com/2/tweets" \
  -H "Authorization: Bearer $X_BEARER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from the free tier"}'

That POST is the one thing the free tier reliably does. Swap it for any GET read endpoint and you get a 403. The credential generation, the common rejection patterns, and the faster alternative path are all covered 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 do not require an X developer account, because they are not X. You sign up directly, copy a key, and call the API. For read-heavy work that removes the slowest and least predictable step in the whole process: waiting on X to approve you.

I Made Twitter API Free

— FaceDev walks through the post-pricing-change reality on YouTube

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

Which Tier Should You Use in 2026?

The decision comes down to one question: do you read data, or only write it? If you only write, the free tier is genuinely free. If you read anything, you are paying, and the only choice is who you pay.

If you want to	Best option
Post tweets from a bot or scheduler	X API free tier (write only, $0)
Read public tweets at low volume	X pay-per-use or a third-party read API
Search tweets programmatically	Third-party API (official search is $0.005 per result)
Pull follower or following lists	Third-party API (official: pay-per-use)
Run sentiment analysis at scale	Third-party API (100K tweets is $5 vs $500 official)
Build a real-time monitoring tool	Third-party API (no rate-window ceiling)
Scrape competitor follower graphs	Third-party API

Which option fits your use case

The pattern is clear from the table: writes belong on the free tier, and reads belong on whatever is cheapest, which at scale is a third-party API. The cost gap is not marginal. At 1 million reads the official API is $5,000 and a direct API is $50, the same data at one percent of the price.

The cost of one million tweet reads

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

Monthly read cost by volume, official vs GetXAPI

To narrow it for your project, model your read and write split. A posting bot stays free. A read pipeline at any meaningful volume is cheaper on a direct API, and you can confirm the exact figures with the cost calculator and the Twitter API alternatives comparison. If your use case is sentiment, the Twitter sentiment analysis tutorial shows the read pipeline end to end, and if you need follower data, the export Twitter followers guide covers the lookup endpoints. The Twitter trends API guide and the Twitter Article API tutorial round out the read endpoints the free tier never exposes.

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

What Happened to the Free Tier's Read Access (and the Legacy Tiers)

The free tier did not always read nothing. Understanding how it got here explains why the 2026 version is so narrow, and why migrating off the old tiers caught so many teams off guard.

From 2006 to early 2023, the free API read freely within rate limits. In February 2023, X removed free read access and introduced paid subscription tiers, a decision announced directly by the platform's developer account and debated heavily at the time. The Basic tier at $200 a month bundled 15,000 reads, and Pro at $5,000 a month bundled a million. Those tiers were the read path for three years. In February 2026, X retired them for new signups and began migrating existing subscribers onto pay-per-use, which is why a project that worked on Basic in January found itself on per-call billing by spring.

If you were on a legacy tier, the migration changes how you forecast cost. A workload that read 100,000 tweets a month inside a $200 Basic subscription now costs $500 at the $0.005 pay-per-use rate, because the bundled quota is gone and every read bills individually. The official migration notices live on the developer pricing pages, and the DataForSEO migration guide and similar third-party references track how the old quotas map to per-call spend. For the GetXAPI side of that math, the Twitter API cost breakdown and the best Twitter API for scraping comparison show what the same volume costs on a direct API.

A quick check of which model your account is on:

# Inspect your usage tier from the response headers on any read call
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 you are on the free write tier, pay-per-use, or a legacy subscription. If reads return 403 and the access level reads write-only, you are on free and need to upgrade to read anything. The send Twitter DMs via API guide covers another endpoint family that the free tier locks out entirely, since DM access has always required a higher tier.

Free Tier Rate Limits, Errors, and the 403 You Will Hit

Even the write-only free tier has rate limits, and they are easy to trip if you do not read the response headers. The POST /tweets endpoint on the free tier caps at the 1,500-per-month write ceiling, enforced as a rolling monthly count, and a per-15-minute request window on top of that. Exceed either and you get a 429 with a reset timestamp.

The error you will actually hit first, though, is the 403 Forbidden on reads, the HTTP status that means your credentials are valid but the resource is off-limits to your tier. Here is how to detect it cleanly so your code fails with a useful message instead of a stack trace:

import os
import requests

resp = requests.get(
    "https://api.x.com/2/tweets/search/recent",
    params={"query": "machine learning", "max_results": 10},
    headers={"Authorization": f"Bearer {os.environ['X_BEARER_TOKEN']}"},
)

if resp.status_code == 403:
    print("403: the free tier has no read access. Search needs pay-per-use.")
elif resp.status_code == 429:
    reset = resp.headers.get("x-rate-limit-reset")
    print(f"429: rate limited, window resets at unix {reset}")
else:
    resp.raise_for_status()
    print("ok:", resp.json()["meta"]["result_count"], "results")

The three headers that govern every official call are x-rate-limit-limit, x-rate-limit-remaining, and x-rate-limit-reset, documented in the X API rate limits reference. When you exceed a window you get a 429 Too Many Requests, so read x-rate-limit-remaining on every response, back off when it nears zero, and respect the reset timestamp. The authentication header patterns that produce these calls are covered in the X API authentication overview, and the user-context write flow builds on the OAuth 2.0 framework with PKCE as defined in RFC 7636. If you build against the official API in Python, most teams reach for the community library Tweepy, which wraps these auth and rate-limit details for you.

On a third-party read API the rate-limit story is simpler: there is no per-window read ceiling, only your credit balance, so the 403-on-free and the 429-on-window problems both disappear. You still want exponential backoff for transient network errors, but you are not fighting the platform's tier gates. The advanced search operators guide and the Twitter API v2 vs GetXAPI comparison show how the read endpoints behave once the tier limits are out of the way.

Summary

So, is the Twitter API free in 2026? The free tier exists, but it is write only: 1,500 posts a month and zero read access. Reading tweets costs money on every path, $0.005 per standard read under pay-per-use, or roughly $0.05 per 1,000 tweets through a third-party read API. The Basic and Pro subscription tiers closed to new signups in February 2026, and the April 2026 update pushed URL-posts and several write actions higher still.

The practical path: if you only post, stay on the free tier and pay nothing. If you read data, use pay-per-use when you are already integrated with X's platform, or a third-party read API when you want read access without a subscription, a developer-account review, or the $0.005-per-read rate. Either way, the word "free" describes a writing tool, not a reading one. Start with the pricing page to see the per-call rates, model your volume with the cost calculator, and grab $0.10 in free credits with no card on the signup page.