Published January 18, 2026 · Updated July 13, 2026
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)
Skip to your trading edge
If you came for trading signals, don't stop at the API price table.
Choose the market where first-source information actually creates the edge.
Memecoin and onchain trading
Track launchpads, founders, KOLs, exchanges, and contract signals.
See the playbookPolymarket news trading
Feed first-source X and Truth Social posts into prediction-market bots.
See the playbookTruth Social trading alerts
Stream supported Trump and White House posts as WebSocket events.
See the playbookAt 200 Posts per watched account/day, 50 accounts cost ~$1,500/mo on X API. TweetStream Minimum: $199/mo flat.
X's publicly priced stream (Filtered Stream) is ~6-7s P99 per their docs. TweetStream's published speed metric is 167ms 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.
- 167ms 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 — source ingestion, enrichment, and upstream recovery are managed by TweetStream
- Flat $199/mo Minimum / $499/mo Pro — no 2M monthly Post-read cap to engineer around
- 3-day trial. Card checkout or stablecoin deposit. 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.
X's public pricing docs currently list Posts: Read at $0.005 per resource, User: Read and follower reads at $0.010, owned reads at $0.001, and Post creation at $0.015 before URL surcharges. X says prices can change, so confirm the current rate in Developer Console before committing architecture.
Current X API Unit Prices
X's public pricing documentation listed these rates when this guide was verified in July 2026:
| Operation | Resource | Public pricing signal | What to verify |
|---|---|---|---|
| Read | Posts | $0.005 per resource | Unique delivered volume after daily dedupe |
| Read | Users, following, and followers | $0.010 per resource | Auth scope, endpoint rate limits, and returned volume |
| Read | Owned resources | $0.001 per resource | The authenticated user must own the developer app |
| Write | Post creation | $0.015 per request | URL-bearing posts are listed separately at $0.200 |
| Read | Profile updates | $0.005 per resource | Event volume and whether Activity API fits the workflow |
| Read | Filtered stream delivered Posts | $0.005 per unique delivered Post; 2M monthly pay-per-use cap | Delivered volume, daily dedupe, and Enterprise needs above the cap |
The buyer gotcha is compounding volume. A small read workload can be cheap, but monitored-account costs climb with every unique delivered Post, stop at the 2M monthly pay-per-use cap, and still leave you owning the stream client, reconnects, enrichment, and alert routing.
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 Filtered Stream runs ~6-7s P99. TweetStream publishes 167ms median server detection.
X's fastest publicly priced stream is the Filtered Stream, which X's own documentation reports at approximately 6-7 seconds P99 latency. That gap exists before you write reconnect, dedupe, OCR, or $ticker code.
X does sell a faster stream—PowerStream—which its docs call the "lowest-latency streaming API." It is available only under select Enterprise plans, with no public list price or published latency number. TweetStream publishes both its price and server-detection metric: $199/month for Minimum.
TweetStream median server detection
167ms
X Filtered Stream P99 (X docs)
~6-7s
X PowerStream price / latency
Not publicly listed
What Pay-Per-Use Actually Costs at Your Volume
The examples below apply X's current public Posts: Read rate of $0.005 to unique delivered volume. Confirm the rate in Developer Console before budgeting because X says prices are subject to change:
| 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 |
| Illustrative 50-account case: ~10,000 unique delivered Posts/day | ~300,000 reads | ~$1,500 at $0.005 per delivered Post; recalc with your console rate | $199 (Minimum, 50 accounts) |
| Illustrative 250-account case: ~50,000 unique delivered Posts/day | ~1,500,000 reads | ~$7,500 at $0.005 per delivered Post; recalc with your console rate | $499 (Pro, 250 accounts + Discord) |
| High-volume aggregator: 5M reads + 100K standard writes | ~5M reads + 100K writes | Enterprise likely; pay-per-use cap may apply | Scale 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 | Minimum: 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—far too slow for latency-sensitive trade alerts
- REST polling is rate-limited — the username-timeline endpoint caps at 1,500 requests per 15 minutes 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 published 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. In an illustrative 50-account scenario receiving roughly 200 Posts per account per day, usage reaches ~300,000 reads/month. At $0.005 per delivered Post, that is about $1,500/mo in API reads alone, before you build the stream client, reconnect logic, storage, enrichment, and alert routing.
TweetStream detects monitored-account events at a 167ms median on our servers, 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 (Minimum, 50 accounts) or $499/month (Pro, 250 accounts plus Discord webhook delivery). For monitored-account alerts specifically, that can be materially cheaper than metered usage once volume grows, while shifting source ingestion, enrichment, storage, and upstream recovery to TweetStream.
| Feature | X API (Pay-Per-Use) | TweetStream Minimum | TweetStream Pro |
|---|---|---|---|
| Pricing model | Per-resource metered | Flat $199/mo | Flat $499/mo |
| ~300K reads/mo (50 accounts × 200 Posts/day) | Model from your Developer Console rate | Included | Included |
| Real-time delivery | HTTP filtered stream | WebSocket | WebSocket |
| Speed proof | Measure in your workload | Published server-detection metric | Published server-detection metric |
| 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 |
| Your integration to maintain | Stream client, broker, store, trading logic | WebSocket consumer + trading logic | WebSocket consumer + trading logic |
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: July 2026