Published January 18, 2026 · Updated August 6, 2026
2026 X API at a glance
Current model
Pay-per-use credits
Pay-per-use commitment
No subscription or minimum spend
Post read rate
$0.005 per returned resource
Post-read cap
2M each billing cycle
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 playbookIf 50 watched accounts return 200 Posts each/day, 300,000 Post resources over 30 days model to ~$1,500 at X's public rate. TweetStream Minimum: $199/mo flat.
X documents roughly 6-7s P99 for its publicly priced Filtered Stream. TweetStream publishes 167ms median server detection and adds deletes, pins, profile/follow signals, $ticker, contract OCR, and live DEX prices. Compare the full signal your bot receives, not the read price alone.
$199/mo (50 accounts) · $499/mo (250 accounts + Discord). 3-day trial.
- Two published reference points: TweetStream's 167ms median server detection and X's documented ~6-7s Filtered Stream P99
- WebSocket payloads include post/account-change alerts, $ticker, contract OCR, and live DEX prices with managed delivery and enrichment
- Flat $199/mo Minimum / $499/mo Pro — no 2M Post-read cap per monthly billing cycle 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's public pay-per-use pricing uses credits bought upfront in Developer Console, then deducts credits as API requests return resources. X says resources are deduplicated within a 24-hour UTC day, calls that deduplication a soft guarantee, and shows live usage and cost in Developer Console. Pay-per-use is capped at 2M Post reads per monthly billing cycle; higher volume moves to Enterprise. Qualifying Owned Reads cost $0.001 per resource.
X's public pricing docs currently list Posts: Read at $0.005 per returned resource, User: Read and follower reads at $0.010 per returned resource, owned reads at $0.001 per returned resource, 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 on August 6, 2026:
| Operation | Resource | Public pricing signal | What to verify |
|---|---|---|---|
| Read | Posts | $0.005 per Post resource | 24-hour UTC dedupe (soft guarantee) |
| 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 profile resource | Event volume and whether Activity API fits the workflow |
| Read | Filtered stream Post reads | $0.005 per Post; 2M-cycle cap | Actual metering, dedupe, and Enterprise needs above the cap |
Costs rise with returned Post volume. Small workloads can be cheap, but monitored-account reads can climb quickly and stop at the 2M cap. You still own 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 Post Reads
Filtered Stream is available on pay-per-use. Register rules, open a long-lived HTTP connection, and X sends matching Posts as newline-delimited JSON. The public rate and 2M cap above still apply; confirm actual resource counts and dedupe in Developer Console.
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.
Latency you can test
Put both published latency markers on your watchlist.
X documents approximately 6-7 seconds P99 for Filtered Stream. TweetStream publishes 167ms median server detection. The percentiles and measurement boundaries differ, so test the same accounts before deciding.
X also sells PowerStream, which its docs call the "lowest-latency streaming API," on select Enterprise plans without a public list price or published latency number. TweetStream publishes both its price and server-detection boundary: $199/month for Minimum.
Read TweetStream's latency measurement methodTweetStream 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 $0.005 Posts: Read rate to a watched-account workload. Confirm the rate and metering in Developer Console 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 |
| Illustrative 50-account case: ~10,000 matched Posts/day | ~300,000 reads | ~$1,500 at the public Post-read rate; recalc with your console metering | $199 (Minimum, 50 accounts) |
| Illustrative 250-account case: ~50,000 matched Posts/day | ~1,500,000 reads | ~$7,500 at the public Post-read rate; recalc with your console metering | $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 publicly prices Posts: Read at $0.005 per Post resource. Adjust accounts and matched Posts per day to compare metered X cost with TweetStream's flat price.
X Posts: Read rate:
$0.005 per Post resource
Public rate from X's pricing docs. The calculator treats each matched Post as one Post resource; verify actual metering and dedupe in Developer Console. Owned Reads are $0.001 only for qualifying endpoints, users, and apps.
| Estimated Post reads per 30 days | 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
- Filtered Stream delivery still needs health checks, reconnect handling, deduplication, and recovery logic
- 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 is capped at 2,000,000 Post reads each billing cycle 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. It assumes each matched Post is one metered Post resource and uses 30 days for volume. Verify resource counts, soft-guarantee 24-hour UTC dedupe, billing-cycle dates, caps, and Enterprise terms in your X Developer Console.
Flat-Rate Alternative for Monitored-Account Workloads
If 50 watched accounts match roughly 200 Posts each per day, that is about 300,000 reads over 30 days—or roughly $1,500 at X's public Post-read rate. That is 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 the post timestamp to TweetStream receipt, 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 TweetStream manages real-time delivery and enrichment.
| 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: August 6, 2026