How Much Does the X (Twitter) API Cost in 2026?
For a new developer, the official X API now bills pay-per-use — about $0.005 per post read with no monthly minimum, hard-capped at 2,000,000 reads/month, so 2M reads costs roughly $10,000/month and anything above forces an Enterprise contract (~$42,000+/month). The legacy $200 Basic and $5,000 Pro tiers are closed to new signups, and the free tier is discontinued. A third-party API like TwitterAPI.io is ~$0.00015 per read ($0.15 per 1,000 tweets) with no floor and no cap — about 33× cheaper at every volume. That covers what most people searching "how much is an X API access key" need; the rest of this page shows the full math.
There's a common misconception that the X API still starts at "$200/month for Basic." That tier exists, but you can no longer sign up for it — new developers are routed to pay-per-use. So the real entry cost isn't a flat $200; it's your read volume × $0.005, which is great at tiny volume (10K reads = $50) and brutal at scale (2M reads = $10,000, then a hard wall).
Below: the current pay-per-use rates, what changed in the February 2026 switch (and the April 2026 write-pricing update), a 4-level cost comparison against the pay-per-call alternative, and a runnable estimator. All figures are from the publicly published pricing on docs.x.com and docs.twitterapi.io.
What does an X API access key actually cost in 2026?
There's no one-time "access key" fee. For a new developer, the official X API is billed pay-per-use — you pay per request, with no monthly subscription. The headline rate is $0.005 per post read, with a hard 2,000,000 reads/month cap. Current published rates:
| Resource | Rate |
|---|---|
| Post read | $0.005 / read |
| User / DM read | $0.010 / read |
| Owned read (your own account's data) | $0.001 / read |
| Post creation | $0.015 / post |
| URL Post creation (since April 2026) | $0.200 / post |
Important accuracy note: the legacy flat tiers — Basic $200/month and Pro $5,000/month — still exist for existing subscribers, but are closed to new signups; a new developer cannot buy the $200 Basic tier. Above the 2M-read cap, the only option is Enterprise (~$42,000+/month). The standalone free tier has been discontinued (new accounts start on pay-per-use with no monthly minimum).
For comparison, TwitterAPI.io (the third-party API this site documents) charges a flat $0.00015 per read — about $0.15 per 1,000 tweets — with no monthly minimum and no cap. A new account gets a $1 trial credit (~6,000 calls), no card required.
What changed in the February 2026 X API pricing?
Before February 2026, the X API was a flat-tier model: pick Basic/Pro/Enterprise, get a fixed monthly allowance, pay the flat fee. The February 2026 switch made pay-per-use the default for new developers and closed Basic/Pro to new signups. Instead of a subscription, you now pay per resource:
- Post read: $0.005 per read (this is the rate that dominates most data projects)
- User / DM read: $0.010 per read
- Owned reads (your own account's data): $0.001 per read
- Post creation: $0.015 per post; URL Post creation: $0.200 per post (added in the April 2026 update)
Two changes matter most. First, there's no monthly minimum — at tiny volume that's cheaper than the old $200 floor (10K reads = $50). Second, the 2,000,000 post-reads/month hard cap remains: once you hit 2M reads you cannot read more that month except by moving to Enterprise (~$42,000+/month). Since post-reads are billed at $0.005, hitting that 2M cap means you've already spent about $10,000 that month — and then the wall.
The net effect is a pricing curve that's friendly at the very low end (no floor) but escalates fast: $0.005/read compounds quickly, and the 2M cap turns into a $10,000-then-Enterprise cliff exactly in the mid-to-high volume range where most monitoring, analytics, and AI-data projects live. (This page focuses on reads because that's what data projects spend on; writes are billed separately at the rates above.)
How does the 2,000,000-read/month cap affect real projects?
Under pay-per-use, the 2M cap isn't just a ceiling — it's a $10,000/month ceiling (2M × $0.005), after which you're forced to Enterprise. That lands hard on "mid-sized" data work:
Real-time brand monitoring: 50 keywords × ~1,000 new tweets/day × 30 days ≈ 1.5M reads/month = ~$7,500/month on the official API (and climbing toward the cap). The same on TwitterAPI.io: ~$225.
KOL / influencer tracking: 500 accounts × ~3 tweets/day × 50 interaction-fetches × 30 days ≈ 2.25M reads/month — over the 2M cap, so the official API forces Enterprise (~$42,000+). TwitterAPI.io: ~$338, no ceiling.
AI training-data collection: 100K tweets/day × 30 days = 3M reads/month — well over the cap; unusable on the official API short of Enterprise. TwitterAPI.io: ~$450.
Low-volume zone (well under 2M): individual PoCs and single-brand monitoring (<500K/month) are where pay-per-use's no-minimum helps most — but $0.005/read still adds up (500K reads = $2,500/month vs TwitterAPI.io's $75). The official API's hook (no floor) only wins at genuinely tiny volume, and even there the per-read rate makes it ~33× the third-party cost.
How much do third-party Twitter APIs cost?
Third-party APIs like TwitterAPI.io use a fundamentally simpler model: linear pay-per-call, no subscription, no cap.
- $0.00015 per call (~$0.15 per 1,000 tweets returned) — about 1/33 of the official $0.005/read
- No monthly minimum — a new account gets $1 trial credit (~6,000 calls), no card required
- No monthly cap — there's no 2M ceiling and no forced Enterprise jump; you scale smoothly
- No tiers — every user gets the same price and the same ~75 endpoints (read + common writes like post/like/retweet/follow; DM-send is intentionally not exposed because API-sent DMs trigger account bans)
The math is monthly cost = monthly reads × $0.00015: 1M reads = $150, 2M = $300, 5M = $750, 10M = $1,500. Because it's the same per-read rate at every volume — and ~33× below the official $0.005 — the cost gap is constant rather than blowing up at a tier boundary.
Which is cheaper for my use case? (cost comparison)
Monthly cost at four common read volumes, using the official pay-per-use rate ($0.005/read) a new developer actually pays vs TwitterAPI.io ($0.00015/read). Figures from publicly published pricing.
| Monthly post-reads | Typical project | Official X API (pay-per-use) | TwitterAPI.io | Gap |
|---|---|---|---|---|
| 10,000 | Individual PoC | $50 | $1.50 | ~33× |
| 100,000 | Small brand monitoring | $500 | $15 | ~33× |
| 1,000,000 | Mid-size SaaS tool | $5,000 | $150 | ~33× |
| 2,000,000 (cap) | Larger monitoring platform | $10,000 | $300 | ~33× |
| above 2,000,000 | Large-scale intelligence | Enterprise (~$42,000+) | linear (e.g. 5M = $750) | 50×+ |
The pattern is clean: at every volume up to the cap, the official pay-per-use rate is ~33× the third-party cost. At the 2M cap you've spent ~$10,000 and hit a wall; above it, the official API forces Enterprise (~$42,000+) while TwitterAPI.io just keeps scaling linearly. Most monitoring / analytics / AI projects live in the 100K-10M range — squarely where pay-per-call wins. The official API is only the right call when you specifically need official-only capabilities (Ads API, verified write at scale, partner status).
Is there a free X API tier?
No — the standalone free tier has been discontinued. New developers start on pay-per-use, which has no monthly minimum (so $0 if you make zero calls) but charges $0.005 per read the moment you actually pull data. There's no longer a free allowance of reads to build against.
In practice that means the cheapest way to try the official API is to make a few pay-per-use calls and pay cents for them — but there's no free quota to prototype a real integration. TwitterAPI.io's equivalent is the $1 trial credit (~6,000 calls, no card required), which can run a meaningful proof-of-concept: pull several thousand tweets, fetch hundreds of profiles, test webhook rules — all before paying anything.
Bottom line on "free": the official free tier is gone; pay-per-use has no floor but isn't free for real usage; and a third-party trial credit is the practical way to validate an integration end-to-end at no cost. See the dedicated free-tier comparison linked below.
How to estimate your monthly API cost
Estimating is straightforward. For the official API (new developer) it's reads × $0.005, until you hit the 2,000,000-read cap, after which you're forced to Enterprise. For TwitterAPI.io it's purely reads × $0.00015.
The estimator below takes your monthly read count and returns both costs side by side, flagging the 2M-cap/Enterprise cliff. For an interactive version with separate sliders per resource type (post reads, user reads, writes), use the rate-limit + cost calculator linked at the bottom.
Rule of thumb for read volume: (keywords × tweets-per-day × 30) + (accounts × polls-per-day × 30) + interaction-fetches. Under ~300K reads/month the official no-minimum is tolerable but still ~33× the third-party cost; anywhere from there to the 2M cap, pay-per-call saves an order of magnitude; above 2M, the official API forces Enterprise and pay-per-call is the only economical path.
# X API monthly cost estimator (2026) — official pay-per-use vs TwitterAPI.io
# New developers are billed pay-per-use; legacy $200 Basic is closed to new signups.
OFFICIAL_READ_RATE = 0.005 # $/post read (new-developer default)
OFFICIAL_CAP = 2_000_000 # hard cap; above this = Enterprise only
ENTERPRISE_FLOOR = 42_000 # ~$/month, contact-sales
TWITTERAPI_RATE = 0.00015 # $0.15 / 1,000 reads
def estimate(monthly_reads: int):
"""Return (official cost label, TwitterAPI.io cost)."""
if monthly_reads > OFFICIAL_CAP:
official = f"exceeds 2M cap -> Enterprise ~${ENTERPRISE_FLOOR:,}+/mo"
else:
official = f"${monthly_reads * OFFICIAL_READ_RATE:,.2f}"
twitterapi = monthly_reads * TWITTERAPI_RATE
return official, twitterapi
for name, reads in [
("Individual PoC", 10_000),
("Small monitoring", 100_000),
("Mid-size SaaS", 1_000_000),
("At the 2M cap", 2_000_000),
("Large intelligence",5_000_000),
]:
official, twitterapi = estimate(reads)
print(f"{name:<20}{reads:>10,} reads official={official:<40} twitterapi=${twitterapi:,.2f}")
# At 2,000,000 reads: official=$10,000.00 twitterapi=$300.00 (~33x cheaper)
# Above 2M the official API forces Enterprise; TwitterAPI.io keeps scaling linearly.Questions readers ask
How much does the X API cost for a new developer in 2026?
New developers are billed pay-per-use: about $0.005 per post read with no monthly minimum, hard-capped at 2,000,000 reads/month. So 10K reads ≈ $50, 1M reads ≈ $5,000, and 2M reads ≈ $10,000 — after which you must move to Enterprise (~$42,000+/month). The old $200 Basic and $5,000 Pro flat tiers are closed to new signups. TwitterAPI.io is ~$0.00015/read (about 33× cheaper) with no floor or cap.
Can I still get the $200 Basic X API tier?
Not as a new signup. The legacy Basic ($200/month) and Pro ($5,000/month) flat tiers still exist for existing subscribers but are closed to new developers — new accounts are routed to pay-per-use ($0.005/post read, no minimum, 2M-read cap). So the commonly-cited "$200 to start" no longer applies to new projects.
Is the X API free?
No — the standalone free tier has been discontinued. New developers start on pay-per-use, which has no monthly minimum (so $0 if you make no calls) but charges $0.005 per read for actual data, with no free read allowance to prototype against. TwitterAPI.io offers a $1 trial credit (~6,000 calls, no card) that can run a real proof-of-concept.
What is the 2 million monthly cap on the X API?
Pay-per-use is hard-capped at 2,000,000 post-reads per month. At $0.005/read that's about $10,000 spent — and once you hit it you cannot read more that month except by moving to Enterprise (~$42,000+/month, a large jump). Third-party APIs like TwitterAPI.io have no such cap, so the same 2M reads cost $300 and you can keep scaling.
Why did the X API get more expensive in 2026?
In February 2026 X made pay-per-use the default for new developers (closing the flat $200 Basic / $5,000 Pro tiers to new signups and discontinuing the free tier), then added URL-post pricing ($0.20/post) in April 2026. Per-read billing at $0.005 plus a 2M-read cap means mid-volume projects pay thousands per month and hit a hard wall — which is why many move to a pay-per-call third-party API.
What's the cheapest way to get Twitter data at scale?
A third-party pay-per-call API. TwitterAPI.io charges $0.00015/read with no floor or cap, so 2M reads = $300 and 5M = $750 — versus the official API's ~$10,000 at the 2M cap and Enterprise (~$42,000+) above it. At every volume the official pay-per-use rate is about 33× the third-party cost, and only the official API forces an Enterprise contract to scale past 2M.
Does the official price include writes, or just reads?
Reads and writes are billed separately. This page focuses on reads ($0.005/post read) because that's what data projects spend on, but the official API also charges for writes: $0.015 per post, $0.20 per URL post (added April 2026), $0.010 per user/DM read, and $0.001 per owned read. TwitterAPI.io's $0.00015/read covers reads; it offers common writes (post/like/retweet/follow) but not DM-send.
Does TwitterAPI.io have hidden fees?
No — pricing is purely per-call ($0.00015 each) against a prepaid balance. No subscription, no minimum spend, no per-seat fees, no monthly cap. You monitor exact spend in the dashboard, and the $1 trial credit (no card) lets you validate cost behavior before committing. For an interactive breakdown, use the rate-limit + cost calculator linked above.
Continue
- X (Twitter) API — official product and access tiers
- X API — official documentation
- X API — official rate limits reference
- TwitterAPI.io pricing →
- X API rate-limit + cost calculator (interactive) →
- Twitter API pricing — detailed breakdown →
- The best third-party Twitter API in 2026 →
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API key