- 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
- 3M each billing cycle
- Filtered stream
- 1 connection, ~4-5 s P99 (X docs)
Once you've compared API prices, see how the feed fits your market.
Choose the market where an early source post matters most.
- Memecoin and onchain tradingTrack launchpads, founders, KOLs, exchanges, and contract signals.
- Polymarket news tradingFeed first-source X posts into prediction-market bots. Pro, Scale, and Ultra Speed include supported Truth Social posts.
- Truth Social trading alertsUse Pro, Scale, or Ultra Speed to stream supported Trump and White House posts over WebSocket and Discord.
50 heavy accounts: about $878/mo on the X API vs $199/mo flat
Assumes 50 watched accounts at 117 Posts a day each, @Polymarket's average over the 30 days to October 3, 2026: 175,500 Post reads, about $878 at X's public rate. At 20 Posts a day, the median for the ten accounts in TweetStream's speed report over the 7 days to October 3, the same list costs about $150 and the X API is cheaper. TweetStream Minimum is $199/mo flat.
X documents about 4-5 s P99 on one Filtered Stream connection. TweetStream publishes rolling server-detection percentiles and adds deletes, pins, profile and follow signals, $ticker, contract OCR, and live DEX prices to each alert.
$199/mo (50 accounts) · $499/mo (250 accounts + history replay). Discord on every plan. 3-day trial.
- Two published reference points: TweetStream's rolling server-detection report and X's documented ~4-5s 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 3M Post-read cap per monthly billing cycle to engineer around
- 3-day trial on Minimum or Pro: 5 tracked accounts and 1 WebSocket. Card trials convert to paid on the billing cycle you choose unless you cancel. Stablecoin trials from a Solana wallet are free and convert to paid unless you turn off auto-renew. Manual stablecoin trials take a non-refundable $5 deposit, and brand-new wallets may need one too; it's credited to your first invoice, and you pay that invoice to continue.
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 3M 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 we last checked it on October 3, 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; 3M-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 3M 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
- Streams do not include backfill. If you disconnect, you 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. Pay-per-use filtered stream allows one connection. Multiple parallel streams require Enterprise, which advertises 25,000 or more rules and multiple concurrent connections through sales.
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 3M 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, compare delivery timing, reconnect behavior, available signals, enrichment, and operational work. If you need push delivery for deletes, pins, profile or follow changes, and token, OCR, or price context, a managed WebSocket service can be simpler to operate than raw stream events.
Put both published latency markers on your watchlist.
X documents approximately 4-5 seconds P99 for Filtered Stream. TweetStream publishes a rolling server-detection report. 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 method- Live p50
- TweetStream median server detection
- ~4-5s
- X Filtered Stream P99 (X docs)
- Not publicly listed
- X PowerStream price / latency
How much does the X API cost to monitor accounts?
Monitoring 50 accounts on the X API costs about $150 to $878 a month in Post reads, depending on how often they post. The rows apply X's $0.005 Posts: Read rate over 30 days. Typical is 20 Posts a day, the median for the ten accounts in TweetStream's speed report over the 7 days to October 3, 2026. Heavy is 117 Posts a day, @Polymarket's average over the 30 days to October 3, 2026. At 50 accounts the X API is cheaper below about 26 Posts per account a day. Each X API figure covers one filtered-stream connection with about 4-5 s P99. Confirm the rate and metering in Developer Console before budgeting.
| Workload | Monthly Post reads | X API cost (1 stream connection, ~4-5 s P99) | TweetStream |
|---|---|---|---|
| Prototype: 100 owned reads/day | ~3,000 owned reads | ~$3 if these qualify as $0.001 owned reads | Not needed; pay-per-use fits |
| Typical: 50 accounts × 20 Posts/day | ~30,000 | ~$150 (the X API is cheaper here) | $199 (Minimum, 50 accounts) |
| Heavy: 50 accounts × 117 Posts/day | ~175,500 | ~$878 | $199 (Minimum, 50 accounts) |
| Typical: 250 accounts × 20 Posts/day | ~150,000 | ~$750 | $499 (Pro, 250 accounts + history replay) |
| Heavy: 250 accounts × 117 Posts/day | ~877,500 | ~$4,388 | $499 (Pro, 250 accounts + history replay) |
| High-volume aggregator: 5M reads + 100K standard writes | ~5M reads + 100K writes | Above the 3M pay-per-use cap, so Enterprise | Scale quote |
Twitter API cost calculator
X publicly prices Posts: Read at $0.005 per Post resource. Pick a measured posting rate or enter your own, then compare metered X cost with TweetStream's flat price.
Typical is the median for the ten accounts in TweetStream's speed report over the 7 days to October 3, 2026. Heavy is @Polymarket's average over the 30 days to October 3, 2026.
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 | 30,000 |
| Estimated X API monthly cost | $150 |
| X API delivery (X docs) | 1 filtered-stream connection, ~4-5 s P99 |
| Closest TweetStream plan | Minimum: 50 accounts for $199/mo |
| TweetStream monthly price | $199 |
| Estimated monthly difference | -$49.00 |
The X API costs less at this volume
For a small or quiet watchlist, metered Post reads cost less than a flat plan. That price covers one filtered-stream connection with about 4-5 s P99, and you run the client, reconnects, and enrichment yourself. REST polling caps the username-timeline endpoint at 1,500 requests per 15 minutes per app. TweetStream's flat price includes managed WebSocket delivery, token detection, image OCR, live prices, and a public speed report.
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 3,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.
X API, Truth API and alert speed factsFlat-rate alternative for monitored-account workloads
At the heavy rate of 117 Posts per account a day, 50 watched accounts return about 175,500 Posts over 30 days, roughly $878 at X's public Post-read rate. That is before you build the stream client, reconnect logic, storage, enrichment, and alert routing.
TweetStream publishes rolling server-detection percentiles for monitored X posts. It delivers WebSocket alerts for posts, updates, deletes, pins, profile changes, follows, and unfollows, with token detection, OCR on attached images, and live crypto prices. Pricing is $199/month flat for Minimum (50 accounts) or $499/month for Pro (250 accounts plus history replay). Both plans include Discord webhook delivery. For monitored-account alerts, the flat rate can be materially cheaper than metered usage as volume grows.
| Feature | X API (Pay-Per-Use) | TweetStream Minimum | TweetStream Pro |
|---|---|---|---|
| Pricing model | Per-resource metered | Flat $199/mo | Flat $499/mo |
| ~175K reads/mo (50 accounts × 117 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 | Built-in webhooks | Built-in webhooks |
| Your integration to maintain | Stream client, broker, store, trading logic | WebSocket consumer + trading logic | WebSocket consumer + trading logic |
Put this workflow into production faster
This guide covers the workflow. TweetStream handles monitored-post ingestion, token detection, and OCR, then delivers posts, updates, deletes, pins, profile changes, follows, unfollows, and enriched JSON payloads over WebSocket. Supported plans also include history. Your client reconnects the WebSocket as documented and routes received events downstream. Start a 3-day trial with your own accounts.
Start 3-day trial