X API Pricing 2026: Pay-Per-Use Rates and What Real-Time Tracking Actually Costs
X (Twitter) moved to pay-per-use API pricing in 2026: per-call rates for reads, writes, and filtered stream — plus the 6–7s tail latency, the real cost math for common workloads, and a flat-rate WebSocket alternative.
X API pricing starts cheap, then scales with every post you read.
If you need real-time monitored-account alerts for trading workflows, compare the metered X API bill against TweetStream's flat WebSocket pricing before you build.
TweetStream starts at $199/mo for 50 monitored accounts.
- Basic monthly trial starts at $199/mo after 3 days
- ~300K monthly reads would cost roughly $1,500 on X API pay-per-use
- WebSocket delivery, OCR, token detection, and live prices are already built in
X API Pricing at a Glance (April 2026)
X API pricing in 2026 is pay-per-use: $0.005 per third-party post read, $0.010 per user lookup, $0.001 per owned read, $0.015 per standard write, and $0.200 per write containing a URL. There is no monthly subscription and no minimum spend, and filtered stream is included with ~6–7 second p99 latency.
The old Basic ($200/mo) and Pro ($5,000/mo) tiers are legacy opt-in for grandfathered accounts only. Rates below reflect docs.x.com as of April 2026 — X has tuned per-endpoint rates several times since 2025, so reconfirm current rates and your account's allocation in the Developer Console before committing architecture.
X API Pay-Per-Use Rate Card (April 2026)
Every endpoint is metered by what you fetch or write. The published per-resource rates:
| Operation | Resource | Rate (USD) | Notes |
|---|---|---|---|
| Read | Posts, lists, spaces, communities, notes, media, analytics | $0.005 each | Most common read class |
| Read | Users, DM events, following, followers, trends | $0.010 each | Higher-cost reads |
| Read | Owned posts, owned followers, owned DMs | $0.001 each | Owned-resource discount |
| Write | Standard write request | $0.015 each | Posts, retweets, follows, etc. |
| Write | Write containing a URL | $0.200 each | Link posts cost ~13× standard |
| Write | DM and user-interaction writes | $0.015 each | Same as standard write |
No monthly cap, no minimum spend — costs scale linearly with volume. Owned-resource reads (your own account) are 5× cheaper than third-party reads. Posts containing a URL cost ~13× a standard write, so bulk link distribution adds up fast.
Operational Limits That Cap Throughput
Pay-per-use removes the monthly cap, but every endpoint still has rate limits and connection 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: ~6–7 seconds at p99 from post to delivery
- Search and lookup endpoints: per-15-minute caps still apply per endpoint
- URL-bearing writes cost ~13× standard ($0.200 vs $0.015) — bulk link posting gets expensive fast
- 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, $0.005 Per Delivered Post
Filtered stream is now included with every pay-per-use account. Register up to 1,000 rules, open one long-lived HTTP connection, and X pushes matching posts as newline-delimited JSON. Each delivered post counts as a $0.005 read on top of the connection itself.
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.
Latency is the catch. Filtered stream typically runs ~6–7 seconds at p99 from post creation to delivery — fine for analytics and listening, slow for trading and alert workflows that compete on speed. For sub-second push, a managed WebSocket service is faster end-to-end and avoids the build cost — see the comparison below.
What Pay-Per-Use Actually Costs at Your Volume
Total cost depends on volume. Three real workloads, costed against the public per-resource rates (reads only — add infrastructure for the streaming client, persistence, and reconnect handling):
| Workload | Monthly Reads | X API Cost | TweetStream Equivalent |
|---|---|---|---|
| Prototype: 100 owned reads/day | ~3,000 owned reads | ~$3 | N/A — pay-per-use is fine here |
| Small monitor: 50 accounts, ~200 posts/day each | ~300,000 reads | ~$1,500 | $199 (Basic, 50 accounts) |
| Active monitor: 250 accounts, ~200 posts/day each | ~1,500,000 reads | ~$7,500 | $499 (Elite, 250 accounts + Discord) |
| High-volume aggregator: 5M reads + 100K standard writes | ~5M reads + 100K writes | ~$26,500 | Enterprise quote |
Flat-Rate Alternative for Monitored-Account Workloads
If you reached this page sizing the X API for tweet alerts, the pay-per-use math gets sharp at scale. Tracking 50 accounts pulling roughly 200 posts/day each is ~300,000 reads/month — about $1,500/mo in metered API cost alone, before you build the streaming client and enrichment layer. And filtered stream's ~6–7s p99 latency is too slow for alert workflows that compete on speed.
TweetStream delivers the same coverage over WebSocket in ~200 ms 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 is roughly 7–15× cheaper than the equivalent pay-per-use spend and ~30× faster at the tail.
| 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) | ~$1,500/mo metered | Included | Included |
| Real-time delivery | HTTP filtered stream | WebSocket | WebSocket |
| Tail latency (p99) | ~6–7 seconds | ~200 ms | ~200 ms |
| 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: tracked-account events, 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
TweetStream Team
Last updated: March 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