Twitter (X) Firehose Pricing — Enterprise vs API Comparison
- X Enterprise full firehose: no public price (interest form) per docs.x.com; X pay-per-use stops at 3M post reads/month ($15,000 at $0.005 each)
- twitterapi.io rule-based filtered stream: $0.00015 per matched tweet, with a $0.00015 minimum per rule check (~$6.48/month per rule at a 60-second interval)
- Typical rule volume 10K-100K tweets/day = $45-450/mo
- Full-firehose premium worth paying for financial-grade + academic-archival only
The firehose price question comes up in two contexts: (1) enterprise dev-team asked to spec cost for a full unfiltered Twitter (X) data ingest, (2) product / SaaS dev-team wondering whether they need full firehose or if rule-based filtered stream is enough. The answer to the second decides the answer to the first — 99% of workloads don't need full firehose.
This guide walks the honest pricing per provider, the volume math where the delta compounds, and the specific workloads where full firehose actually pays off. Pricing references URL-cited to each provider.
~$45/mo (twitterapi.io) vs ~$1,500/mo at X's $0.005 per post read (300K posts) — ~33× per docs.x.com + twitterapi.io/pricing
The two price tiers — full firehose vs rule-based filtered stream
X Enterprise (full firehose): every public tweet, delivered in real-time, no filter. X publishes no Enterprise price; you apply through an interest form (docs.x.com/x-api/getting-started/pricing). Multi-year contracts, dedicated support, SLA commitments.
twitterapi.io filtered_stream + webhook (rule-based): register a rule, receive only tweets matching that rule. Billed $0.00015 per matched tweet, with a $0.00015 minimum per check (~$6.48/month per rule at a 60-second interval, which only matters at low volume) per twitterapi.io/pricing. No monthly minimum, no enterprise contract.
The delta is not incremental: against X's pay-per-use read rate it is about 11× to 33× in the math below, and full firehose sits above that on an unpublished Enterprise contract. Understanding which pricing applies to which use case is 90% of the cost-decision.
X Powerstream: the Enterprise low-latency stream and what it costs to get
Short answer. X Powerstream is the X API v2 streaming endpoint that X's own docs call its "lowest-latency streaming API" for public posts (docs.x.com/x-api/powerstream/introduction). It is not on the pay-per-use rate card: the docs describe it as "a premium offering available under select Enterprise plans", reached by submitting the Enterprise Request Form to X's Sales team, and no price is published. So the cost of Powerstream is whatever your Enterprise contract says, on top of the same unpublished Enterprise pricing that covers the full firehose above.
What it is, per the docs. You open one long-lived HTTP connection to https://api.x.com/2/powerstream and manage filters through /2/powerstream/rules with PowerTrack-style keywords and operators. The docs list up to 1,000 rules per stream, each up to 2,048 characters, and a rule-management limit of 50 requests per 24 hours (streams themselves have no request limit, but connection limits apply). The payload uses the same format as the legacy GNIP PowerTrack API, so teams migrating old PowerTrack consumers keep their parsers.
Why it is faster. X contrasts Powerstream with its other streaming endpoints, which "prioritize data hydration and delivery" at roughly 4-5 seconds P99 latency. Powerstream adds a localDcOnly=true query parameter that returns only posts created in the datacenter you are connected to, which skips cross-datacenter replication lag; the connected datacenter comes back in an x-powerstream-datacenter response header and an initial connection_metadata message. The docs suggest opening connections from several regions (their example names Atlanta and Portland) and merging the streams yourself. X does not publish a Powerstream latency number, only that it is lower than the 4-5 second figure.
Edits arrive as separate posts. Each edit gets a new post ID and Powerstream delivers every version that matches your rules; add -is:edit to a rule to keep only the original version. Budget your dedupe logic for that.
The pay-as-you-go alternative. If the requirement is "tweets matching my rules within seconds" rather than a contractual low-latency feed, a TwitterAPI.io tweet filter rule (/oapi/tweet_filter/add_rule, then /oapi/tweet_filter/update_rule to activate it) delivers matches to your webhook or WebSocket and bills 15 credits per tweet returned, i.e. $0.15 per 1,000 tweets. You choose how often the rule is checked with interval_seconds (docs.twitterapi.io lists a range of 0.05 to 86,400 seconds); a check that finds nothing still costs the $0.00015 minimum, so one rule checked every 60 seconds has a floor of 43,200 checks, or $6.48 a month, and shorter intervals raise that floor proportionally. We have not published a measured end-to-end latency for this path, so test it against your own threshold before you rule Powerstream in or out.
When Powerstream is the right buy. Choose it when delivery faster than the 4-5 second P99 of X's other streams is a hard requirement (trading signals, newsroom alerting, incident response) and you already have, or can justify, an X Enterprise agreement. If you cannot name the latency threshold that a few seconds would break, start with a rule-based stream and escalate only when you can show the gap.
Volume math — where the delta compounds
Small rule (brand mentions, ~500 tweets/day): checked every 60 seconds, most checks return zero or one tweet, so the $0.00015 per-check minimum dominates: rule-based ≈ $0.23/day = ~$6.80/month. Reading the same 15,000 tweets a month at X's $0.005 per post read: $75/month. Delta: ~11×.
Medium rule (topic monitoring, ~10K tweets/day): rule-based $1.50/day = ~$45/month. At $0.005 per post read: 300,000 × $0.005 = $1,500/month. Delta: ~33×.
Large rule (broad keyword firehose, ~100K tweets/day): rule-based $15/day = ~$450/month. At $0.005 per post read: 3,000,000 × $0.005 = $15,000/month, exactly X's 3M monthly pay-per-use cap. Delta: ~33×.
Massive rule (multi-topic aggregation, ~1M tweets/day): rule-based $150/day = ~$4,500/month. 30M tweets a month is ten times X's 3M pay-per-use cap, so the official route is Enterprise only (no public price).
Full unfiltered (everything, ~500M+ tweets/day): rule-based math doesn't apply. Full firehose is the only path.
When full firehose pays off
Full firehose is worth an Enterprise contract for these specific workloads:
Financial-grade signal aggregators: Bloomberg-tier products where seconds of latency + missing tweets is unacceptable + revenue justifies the spend.
Academic-archival institutions: LOC-style long-term preservation programs where 'archive every public tweet' is the mandate.
Regulatory compliance archival: legal-hold or jurisdiction-mandated archives that require totality, not filter-scoping.
Platform-level research: unbiased sampling for statistical study of the platform as a whole (filter rules bias the sample by matching only what you rule for).
Discovery use cases with unknown-unknown filters: you don't yet know what keywords or accounts will matter — full firehose lets you archive first + filter later.
Everyone else: rule-based filtered stream at $0.00015/tweet.
Side-by-side — full firehose vs rule-based
Two practical observations: (a) at Fortune-500 brand-monitoring scale, rule-based pricing lands somewhere between $50-500/month — a rounding error for the same team's other SaaS spend; (b) at TB/day archival scale, only full firehose covers the volume without engineering around per-tweet cost accumulation.
How to estimate your workload cost
Step 1: define your rule set. What tweets do you actually need? Brand mentions? Keyword firehose? Multi-account aggregation? Write out the query operators.
Step 2: sample-test the rule at low volume. Use twitterapi.io's advanced_search endpoint with the same query for a 24h window. Multiply the returned count by 30 for monthly volume estimate.
Step 3: apply the pricing. Monthly cost via twitterapi.io ≈ matched tweets × $0.00015, but never less than the per-check floor (checks per month × $0.00015; one rule at a 60-second interval is 43,200 checks = $6.48). Compare against X's pay-per-use read rate (matched tweets × $0.005, up to the 3M monthly cap) or an Enterprise quote. Unless you're in the specific full-firehose use cases above, the rule-based path wins by more than an order of magnitude.
Step 4: budget for growth. If your product succeeds, matched volume grows. Track $/tweet ratio; if your matched-tweet cost approaches what an Enterprise quote would cost you, revisit the full-firehose economics.
Common pricing pitfalls to avoid
Assuming 'firehose' means all of X's tweet volume: most 'give me the firehose' asks mean 'give me a lot of tweets fast'. Almost always a rule-based subset is what the requester actually needs. Clarify before repricing.
Undercounting matched tweets: rules that seem narrow ("YourBrand") can match more than expected once you include mentions, misspellings, and retweets. Sample-test before committing.
Ignoring downstream costs: streaming tweets is cheap; storing + processing them at scale isn't. Budget for warehouse ingest + query cost + retention policy in addition to per-tweet API cost.
Buying full firehose 'just in case': expensive insurance. Prefer starting rule-based + escalating if you demonstrably need full firehose. An Enterprise contract is a real commitment.
# Practical example: rule-based volume estimation for firehose cost forecasting.
import os, requests
from datetime import date, timedelta
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_KEY"]}
BASE = "https://api.twitterapi.io"
def estimate_daily_volume(query: str) -> int:
"""Sample matched-tweet count over 24h for rule volume estimation."""
yesterday = (date.today() - timedelta(days=1)).isoformat()
today = date.today().isoformat()
full_query = f"{query} since:{yesterday} until:{today}"
tweets, cursor = 0, None
for _ in range(50):
params = {"query": full_query}
if cursor: params["cursor"] = cursor
r = requests.get(f"{BASE}/twitter/tweet/advanced_search", headers=HEADERS, params=params, timeout=15)
r.raise_for_status()
resp = r.json()
tweets += len(resp.get("tweets", []))
cursor = resp.get("next_cursor")
if not cursor: break
return tweets
def estimate_monthly_cost(query: str) -> dict:
daily = estimate_daily_volume(query)
monthly_tweets = daily * 30
twitterapi_monthly = monthly_tweets * 0.00015
# X pay-per-use: $0.005 per post read, capped at 3M post reads/month (Enterprise above, no public price)
x_pay_per_use_monthly = monthly_tweets * 0.005 if monthly_tweets <= 3_000_000 else None
return {
"rule": query,
"daily_volume": daily,
"monthly_volume": monthly_tweets,
"twitterapi_monthly_cost": round(twitterapi_monthly, 2),
"x_pay_per_use_monthly": x_pay_per_use_monthly,
"ratio": round(x_pay_per_use_monthly / max(twitterapi_monthly, 0.01), 1) if x_pay_per_use_monthly else None,
}
# Estimate for a hypothetical rule
result = estimate_monthly_cost('"machine learning" min_faves:50 -is:retweet lang:en')
print(f"Rule: {result['rule']}")
print(f"Daily volume: {result['daily_volume']} tweets")
print(f"Monthly volume: {result['monthly_volume']:,} tweets")
print(f"twitterapi.io monthly cost: ${result['twitterapi_monthly_cost']}")
if result['x_pay_per_use_monthly'] is None:
print("X official: above the 3M pay-per-use cap, Enterprise only (no public price)")
else:
print(f"X pay-per-use: ${result['x_pay_per_use_monthly']:,.2f}/mo")
print(f"Delta ratio: {result['ratio']}x via twitterapi.io")
# Costs from cited pricing pagesResearching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.
Questions readers ask
Why is X Enterprise firehose expected to be expensive?
X doesn't publish an Enterprise price, so the only real figure is the quote you get from sales. It's positioned as an enterprise product bundled with dedicated support, SLA, a multi-year contract, and unfiltered coverage of the entire public tweet volume, which is costly to deliver in guaranteed real time, and it targets financial-grade and institutional customers.
Can I negotiate the X Enterprise price?
Enterprise contracts typically have negotiation levers (volume commitment, contract length, feature bundle). But X publishes no Enterprise price, so any figure comes from the quote you get. If your budget is $10K/month you're in pay-per-use or twitterapi.io rule-based territory, not enterprise.
What if I need real-time but only for one specific X account?
That's not firehose — it's Account Activity API territory. See /blog/twitter-webhooks-real-time-api-guide for the per-account webhook path. Cheaper than firehose + right-sized for the use case.
How does twitterapi.io keep the per-tweet price so low?
Volume + infrastructure amortization. Serving many customers off shared streaming infrastructure at sub-cent per tweet is workable; single-tenant unfiltered firehose isn't. Both models are legitimate; they serve different customer segments.
If my product succeeds, will I outgrow twitterapi.io?
Rarely. Even at 10× SaaS-brand-monitoring scale (multi-brand, multi-region) monthly matched-tweet volume typically stays in five-figure tweets/day, which is roughly $1.50–$15 per day at twitterapi.io rates. Full-firehose becomes the right call only when your workload requires the full unfiltered volume.
Is there a middle-tier between rule-based and full firehose?
X historically had Decahose (10% sample) and Sample-1% APIs for statistical work. Both sunset around 2023. Current landscape: full firehose OR rule-based. Multi-rule filtered_stream (register N rules matching your interests) covers most 'partial firehose' use cases at a fraction of full-firehose cost.
Continue
- twitterapi.io — pricing
- X API — pricing (docs.x.com, 2026 verified)
- X Enterprise — overview
- X API — Powerstream introduction (docs.x.com)
- twitterapi.io docs — add tweet filter rule
- Twitter (X) API — cluster hub
- Twitter (X) firehose API — developer guide
- Twitter (X) streaming API — real-time guide
- X (Twitter) official API pricing breakdown
- twitterapi.io pricing
- 01How to Log Out of Twitter (X) on Web, iPhone and Android
- 02How to Change Your Twitter (X) Username, Step by Step
- 03Twitter (X) API timeline: get a user's tweets, page by page
- 04Twitter (X) User API: Get Profiles and Understand Every Field of the User Object
- 05Twitter (X) Feed API: How to Build Your Own Feed in 2026
- 06Gumloop Pricing in 2026: Pro Plan, Credits, and Lindy and Relevance AI Compared
- 07Twitter (X) Analytics Tools — A Developer's Honest Roundup
- 08Twitter (X) Analytics Free — A Tier Comparison
Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API keyAlready building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.