Twitter API Pricing 2026
What X charges in 2026, with sources: pay-per-use credits replaced the old monthly tiers, Posts: Read is $0.005, owned reads $0.001, and a 2M monthly cap. Calculator below.
2026 X API at a glance
Current model
Pay-per-use credits
Free / Basic / Pro tiers
Replaced by pay-per-use
Post read rate
$0.005 per Post
Monthly Post-read cap
2M (pay-per-use)
Tracking 50 accounts on X API: ~$1,500/mo. TweetStream: $199/mo flat.
X's publicly priced stream (Filtered Stream) is ~6-7s P99 per their docs. TweetStream's published speed metric is 170ms median server detection, with deletes, pins, profile/follow signals, $ticker, contract OCR, and live DEX prices attached.
$199/mo (50 accounts) · $499/mo (250 accounts + Discord). 3-day trial.
- 170ms median server detection on TweetStream — versus ~6-7s P99 on X's publicly priced Filtered Stream (X docs)
- WebSocket payloads include post/account-change alerts, $ticker, contract OCR, and live DEX prices — no stream code to write
- Flat $199/mo Basic / $499/mo Elite — no 2M monthly Post-read cap to engineer around
- 3-day trial. Card required for trial setup. Manage or cancel any time from the dashboard.
X API Pricing at a Glance
X API pricing in 2026 is pay-per-use. The old Free, Basic, and Pro monthly subscriptions are gone for new customers — you now buy credits upfront, each endpoint call deducts from that balance, repeated reads of the same resource are deduped within a 24-hour UTC window, and live usage is visible in the Developer Console. Enterprise remains a separate, custom-priced tier for volumes above the pay-per-use caps. X public docs also call out owned reads at $0.001 per resource and a 2M monthly Post-read cap on pay-per-use plans.
Important: X now tells developers to view current per-endpoint rates in the Developer Console because rates can vary by endpoint type, operation, and data scope. Treat any copied public rate card as a snapshot, not as the source of truth. Use the math below as a planning model, then replace the rate with the value shown in your own console before committing architecture.
What X Publishes Publicly vs What Lives in Developer Console
For May 2026 planning, these are the public pricing facts we can verify from X docs without logging into your developer console:
| Operation | Resource | Public pricing signal | What to verify |
|---|---|---|---|
| Read | Third-party Posts and other non-owned resources | Pay-per-use; exact current rate in Developer Console | Your endpoint-specific Post-read rate and whether dedupe applies to your workload |
| Read | Users, timelines, DMs, follows, trends, and other resource types | Pay-per-use; exact current rate in Developer Console | Endpoint-specific rate, auth scope, and rate limits |
| Read | Owned posts, owned followers, owned DMs | $0.001 per owned resource is called out publicly | Which resources count as owned in your account and app context |
| Write | Standard write request | Pay-per-use; exact current rate in Developer Console | Write endpoint rate, media/link handling, and policy constraints |
| Write | URL-bearing writes | Pay-per-use; exact current rate in Developer Console | Whether URL writes have a higher endpoint rate in your console |
| Read | Filtered stream delivered Posts | Each unique delivered Post counts toward usage; 2M monthly cap on pay-per-use | Delivered-Post volume, dedupe behavior, and Enterprise needs above the cap |
This is the main buyer gotcha: public docs explain the model, but your account console is the only current source for endpoint-level rates. The planning question is not only price per request; it is how many unique Posts your monitored accounts produce, how much dedupe helps, whether you hit the 2M cap, and how much infrastructure you need to run the stream reliably.
Operational Limits That Cap Throughput
Pay-per-use changes billing, but every endpoint still has rate limits, connection caps, and usage caps that bound real throughput:
- Filtered stream: 1 concurrent connection, 1,000 rules per project, 1,024-character rule length
- Sampled stream: 1 concurrent connection, ~1% sample of public posts
- Filtered stream latency and delivery behavior should be measured in your own workload before relying on it for trading alerts
- Search and lookup endpoints: per-15-minute caps still apply per endpoint
- Write and URL-bearing write costs should be checked in Developer Console before bulk posting
- No backfill on streams — disconnects lose data unless you have an out-of-band recovery path
Hit a rate limit and you receive a 429 with an x-rate-limit-reset header. Build exponential backoff and idempotency from day one. The 1-connection filtered-stream cap is the binding constraint for serious real-time work — Enterprise (25,000+ rules, multiple concurrent connections, contact sales) is the only way to run multiple parallel streams.
Filtered Stream on Pay-Per-Use: One Connection, Metered Delivered Posts
Filtered stream is available on pay-per-use. Register rules, open a long-lived HTTP connection, and X pushes matching Posts as newline-delimited JSON. Each unique delivered Post counts toward usage, with public docs noting daily dedupe and a 2M monthly Post-read cap on pay-per-use plans.
X's stream is HTTP chunked transfer (not WebSocket). Your client handles the long-lived connection, parses newline-delimited JSON, manages reconnects with exponential backoff, and watches for the keep-alive newlines X sends roughly every 20 seconds to detect stalled connections.
For trading alerts, the practical question is not just X API access; it is delivery timing, reconnect behavior, what signals you actually receive, enrichment, and operational burden. If you need push delivery for deletes, pins, profile/follow moves, and token/OCR/price context, a managed WebSocket service can be simpler to operate than building on raw stream events.
The latency reality
Pay-per-use X API is not a 170ms median monitored-account alert path. The fast lane starts around $42k/mo.
X's fastest publicly priced stream is the Filtered Stream, which X's own documentation reports at approximately 6-7 seconds P99 latency. TweetStream's published speed metric is 170ms median server detection, before you write reconnect, dedupe, OCR, or $ticker code.
X does sell a faster stream — PowerStream — which their docs describe as their "lowest-latency streaming API." But X publishes it as a "premium offering available under select Enterprise plans," with no list price, no published latency number, and access gated behind a sales contract. Third-party reporting puts X's Enterprise tier starting price around $42k/mo. TweetStream's flat $199/mo Basic plan provides WebSocket alerts with 170ms median server detection.
TweetStream's median server detection
170ms median
X Filtered Stream P99 (X docs)
~6-7s
X PowerStream / Enterprise floor
~$42k/mo+
What Pay-Per-Use Actually Costs at Your Volume
Total cost depends on your Developer Console rates and unique delivered-resource volume. The examples below show the planning model for monitored-account reads; replace the assumed Post-read rate with your current console rate before budgeting:
| Workload | Monthly Reads | X API Planning Cost | TweetStream Equivalent |
|---|---|---|---|
| Prototype: 100 owned reads/day | ~3,000 owned reads | ~$3 if these qualify as $0.001 owned reads | N/A — pay-per-use is fine here |
| Small monitor: 50 accounts, ~200 posts/day each | ~300,000 reads | ~$1,500 at $0.005 per delivered Post; recalc with your console rate | $199 (Basic, 50 accounts) |
| Active monitor: 250 accounts, ~200 posts/day each | ~1,500,000 reads | ~$7,500 at $0.005 per delivered Post; recalc with your console rate | $499 (Elite, 250 accounts + Discord) |
| High-volume aggregator: 5M reads + 100K standard writes | ~5M reads + 100K writes | Enterprise likely; pay-per-use cap may apply | Enterprise quote |
Twitter API Cost Calculator
X charges $0.005 per delivered Post on pay-per-use plans. Adjust accounts and Posts/day to compare metered X cost against TweetStream's flat price.
X delivered-Post rate (Posts: Read):
$0.005 per Post
Fixed from X public pricing docs. Owned reads are $0.001; this calculator targets third-party monitoring, which bills at $0.005.
| Estimated monthly delivered Posts | 300,000 |
| Estimated X API monthly cost | $1,500 |
| Closest TweetStream plan | Basic: 50 accounts for $199/mo |
| TweetStream monthly price | $199 |
| Estimated monthly difference | $1,301 |
X API operational constraints (not priced above)
- Filtered stream is limited to 1 connection on pay-per-use; rules are capped at 1,000 per project at 1,024 chars each
- X public docs report ~6-7s P99 latency on filtered stream — unusable for trade alerts
- REST polling is rate-limited — user-timeline endpoints cap at ~1,500 requests / 15 min per app, so you can't poll your way to low-latency alerts
- Pay-per-use plans are capped at 2,000,000 Post reads per month before Enterprise is required
- You still build and operate the stream client, reconnect logic, dedupe, OCR, $ticker detection, and price enrichment
The X cost above is metered Posts: Read only. TweetStream's flat price includes WebSocket delivery, content/update/delete/pin/unpin events when observed, profile/follow/unfollow events when available, $ticker detection, image OCR, live DEX prices, and a 170ms median server-detection metric.
Model only. Per-endpoint rates, dedupe, caps, and Enterprise terms must be verified in your X Developer Console.
Flat-Rate Alternative for Monitored-Account Workloads
If you reached this page sizing the X API for tweet alerts, model unique delivered Posts first. Tracking 50 accounts at roughly 200 Posts/day each is ~300,000 reads/month before dedupe. At an example $0.005 delivered-Post rate that is about $1,500/mo in API reads alone, before you build the stream client, reconnect logic, storage, enrichment, and alert routing.
TweetStream reports 170ms median server detection for monitored-account events, measured from production database event timestamps, then delivers WebSocket alerts for posts, updates, deletes, pins, profile changes, follows, and unfollows with token detection, OCR on attached images, and live crypto prices for $199/month flat (Basic, 50 accounts) or $499/month (Elite, 250 accounts plus Discord webhook delivery). For monitored-account alerts specifically, that can be materially cheaper than metered usage once volume grows, while also removing the stream infrastructure work.
| Feature | X API (Pay-Per-Use) | TweetStream Basic | TweetStream Elite |
|---|---|---|---|
| Pricing model | Per-resource metered | Flat $199/mo | Flat $499/mo |
| ~300K reads/mo (50 accounts) | Model from your Developer Console rate | Included | Included |
| Real-time delivery | HTTP filtered stream | WebSocket | WebSocket |
| Speed proof | Measure in your workload | 170ms median server detection on TweetStream servers | 170ms median server detection on TweetStream servers |
| Concurrent connections | 1 (Enterprise for more) | Managed | Managed |
| Token detection | Build it yourself | Yes | Yes |
| OCR (image text) | Build it yourself | Yes | Yes |
| Live token prices | Build it yourself | Yes | Yes |
| Discord delivery | DIY integration | No | Built-in webhooks |
| Infrastructure to maintain | Streaming client, broker, store | None | None |
Build it faster with TweetStream
This guide explains the workflow, but production teams should not rebuild tweet ingestion, reconnects, token detection, OCR, and downstream delivery from scratch. TweetStream is the better production starting point: posts, updates, deletes, pins, profile changes, follows, unfollows, enriched JSON payloads, history on supported plans, and a 3-day trial you can test against your own accounts.
Start 3-day trialFrequently Asked Questions
Sources
TweetStream Team
Last verified: May 2026
Start real-time Twitter WebSocket alerts today
WebSocket delivery, OCR, and token detection - no infrastructure to build.
Start 3-Day TrialFrom $199/mo · Basic/Elite 3-day trial · OCR + token detection included
