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.

$199/mo Basic170ms median5 trial accounts
Verified May 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)

Flat-rate alternative

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:

OperationResourcePublic pricing signalWhat to verify
ReadThird-party Posts and other non-owned resourcesPay-per-use; exact current rate in Developer ConsoleYour endpoint-specific Post-read rate and whether dedupe applies to your workload
ReadUsers, timelines, DMs, follows, trends, and other resource typesPay-per-use; exact current rate in Developer ConsoleEndpoint-specific rate, auth scope, and rate limits
ReadOwned posts, owned followers, owned DMs$0.001 per owned resource is called out publiclyWhich resources count as owned in your account and app context
WriteStandard write requestPay-per-use; exact current rate in Developer ConsoleWrite endpoint rate, media/link handling, and policy constraints
WriteURL-bearing writesPay-per-use; exact current rate in Developer ConsoleWhether URL writes have a higher endpoint rate in your console
ReadFiltered stream delivered PostsEach unique delivered Post counts toward usage; 2M monthly cap on pay-per-useDelivered-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:

WorkloadMonthly ReadsX API Planning CostTweetStream Equivalent
Prototype: 100 owned reads/day~3,000 owned reads~$3 if these qualify as $0.001 owned readsN/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 writesEnterprise likely; pay-per-use cap may applyEnterprise 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 Posts300,000
Estimated X API monthly cost$1,500
Closest TweetStream planBasic: 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.

FeatureX API (Pay-Per-Use)TweetStream BasicTweetStream Elite
Pricing modelPer-resource meteredFlat $199/moFlat $499/mo
~300K reads/mo (50 accounts)Model from your Developer Console rateIncludedIncluded
Real-time deliveryHTTP filtered streamWebSocketWebSocket
Speed proofMeasure in your workload170ms median server detection on TweetStream servers170ms median server detection on TweetStream servers
Concurrent connections1 (Enterprise for more)ManagedManaged
Token detectionBuild it yourselfYesYes
OCR (image text)Build it yourselfYesYes
Live token pricesBuild it yourselfYesYes
Discord deliveryDIY integrationNoBuilt-in webhooks
Infrastructure to maintainStreaming client, broker, storeNoneNone

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 trial

Frequently Asked Questions

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 Trial

From $199/mo · Basic/Elite 3-day trial · OCR + token detection included

Related Pages