Twitter (X) Enterprise API: What It Includes, Who Needs It, and What It Costs

By TwitterAPI.io Team•16 min read
Diagram: X pay-per-usage up to a 3M monthly post-read cap, X Enterprise above it under a sales contract, and TwitterAPI.io at $0.15 per 1,000 tweets across all volumes
Where the X Enterprise API starts: pay-per-usage stops at 3 million post reads a month; above it X asks for a contract.
TL;DR
  • Enterprise is X's contract tier. Custom price, sales form, named account manager; docs.x.com publishes no number.
  • The trigger is volume. X pay-per-usage is capped at 3 million post reads a month ($0.005 each); above that, X points you to Enterprise.
  • Enterprise-only features: full firehose and language streams, likes streams, Powerstream, engagement metrics, Account Activity, stream webhooks, 5,000+ stream rules.
  • Reported price, not a list price: in 2023 Wired reported Enterprise packages of $42,000, $125,000 and $210,000 a month (50M, 100M, 200M tweets).
  • Our study: 26.3% of 529 public posts about the X Enterprise API quote a dollar figure; 7.8% still cite the 2023 $42,000 figure.
  • Below the firehose: TwitterAPI.io reads tweets at $0.15 per 1,000 with no contract: 10M tweets a month is $1,500, 50M is $7,500.

People who search for the Twitter Enterprise API usually want three answers: what Enterprise gives you that the normal X API does not, at what point X makes you buy it, and roughly what it costs. X answers the first two in its developer docs. It does not answer the third, and most pages that rank for the term still repeat figures from 2023 as if they were a current price list.

This page sticks to that one question. It summarizes what docs.x.com says Enterprise includes, shows exactly where the pay-per-usage plan stops, separates reported prices from published ones, and prices the tweet volumes most teams actually need on both X's rate card and ours. It also includes a small study we ran on public posts about the Enterprise API and on X's own developer channel, so you can see what other buyers focus on. For every X plan side by side, see our broader X API pricing guide; this page covers Enterprise only.

Public posts about the X Enterprise API that quote a dollar figure (of 529, collected in 2026)

26.3%

01 — Section

What the X Enterprise API is, according to X

X describes the Enterprise plan as "the highest level of access to X data" on its Enterprise introduction page (docs.x.com/enterprise-api/introduction). It is not a separate API with different endpoints for everything: you use the same v2 endpoints as everyone else (api.x.com/2/...), plus a set of endpoints that only Enterprise accounts can call, under custom rate limits that your account manager configures.

It is a contract, not a self-serve plan. The Enterprise pricing page (docs.x.com/enterprise-api/getting-started/pricing) lists four properties: custom packages tailored to data volume, endpoint needs and throughput; committed contracts with longer-term agreements and committed usage levels; no fixed post-read cap ("custom or unlimited post read volumes"); and dedicated support with a named account manager and priority technical support.

It is built for continuous, high-volume consumption. The headline feature is complete firehose access: X says Enterprise lets you "stream 100% of public posts in real-time", plus language-specific firehoses for English, Japanese, Korean and Portuguese posts and 1% and 10% sampled streams. Those are push streams. Nothing in the pay-per-usage plan delivers every public post.

It is where X keeps its event and analytics products. Account Activity subscriptions (real-time user events such as posts, DMs, likes and follows), engagement metrics at scale and compliance streams for posts, users and likes are all listed on the Enterprise pages as Enterprise-exclusive. If your product depends on any of them, no self-serve plan replaces the contract.

Who it is for. X's access form asks for company details, intended use case and expected data volume, and X's page frames Enterprise around "organizations that depend on X data at scale". Read together with the feature list, the tier fits teams that need the full public stream, event subscriptions across many accounts, or post volumes well above 3 million a month; X's own partner posts mention social media management platforms among its long-standing Enterprise partners.

02 — Section

Enterprise vs pay-per-usage: the features X reserves for contracts

A direct view of the Enterprise tier is X's own comparison table. We reproduce its rows below (from docs.x.com/enterprise-api/introduction and the Enterprise pricing page, checked in 2026). Everything in the left column is self-serve; everything only in the right column needs a contract.

FeatureX pay-per-usageX Enterprise
Post searchRecent and full-archiveRecent and full-archive
Filtered streamUp to 1,000 rules5,000+ rules, plus embedding: operator (Embedding tier)
Volume streams (firehose)Not availableFull firehose and language streams
Likes streamsNot availableFull and sampled likes
PowerstreamNot availableLow-latency filtered streaming
Engagement metricsNot availablePost and media analytics
Account ActivityNot availableReal-time user event subscriptions
Monthly post cap3 million readsCustom or unlimited
Rate limitsStandardCustom or elevated
SupportCommunity forumDedicated account manager
CommitmentNoneContract-based

Read the table by need, not by feature count. If your product needs every public post as it is published (the firehose), likes as events, or webhooks for user activity across many accounts, Enterprise is the only official route. If you need search, timelines, profiles and filtered streams under 3 million post reads a month, pay-per-usage already covers it, and Enterprise only adds a support contract and higher limits.

Two details that change the math. First, X deduplicates billing: the pay-per-usage page says a resource you already paid for is not charged again if you request it within the same 24-hour UTC day window, and it calls that a soft guarantee. Second, reads of your own app's data ("Owned Reads") are priced at $0.001 per resource instead of $0.005. Both lower the effective bill for repeat or first-party reads, but neither raises the 3 million cap on post reads.

03 — Section

When X requires Enterprise: the 3 million post-read cap

The pay-per-usage pricing page (docs.x.com/x-api/getting-started/pricing) states the rule in one sentence: pay-per-usage plans are capped at 3 million post reads per monthly billing cycle, and if you need higher volume you upgrade to an Enterprise plan. That cap, not a feature list, is what sends most teams to the sales form.

What the cap means in dollars. At $0.005 per post read, the cap is reached at $15,000 of post reads in a billing cycle. A team reading 100,000 posts a day hits it on day 30; a team reading 200,000 a day hits it halfway through the month. Above that line X does not sell more reads at a published price.

What counts toward it. The cap is on post reads: every post returned by search, timelines, lookups and streams. User reads ($0.010 per resource), follower and following reads ($0.010) and writes are priced separately on the same page. A product that mostly reads profiles or follower graphs can spend a lot on pay-per-usage without touching the post cap.

What happens if you only sometimes exceed it. X's docs do not describe a burst allowance or overage price above 3 million. The documented options are to stay under the cap (sample, deduplicate, narrow your queries) or to move to an Enterprise contract. Teams with seasonal peaks, such as an election or a product launch, should plan that conversation before the peak rather than during it.

Monitoring your usage. X points Enterprise customers to the Usage endpoint (GET https://api.x.com/2/usage/tweets), which returns daily post consumption counts. The same endpoint is useful on pay-per-usage to see how close you are to the cap before it bites.

04 — Section

What the X Enterprise API costs: published vs reported

Published price: none. Every Enterprise page on docs.x.com says the same thing in different words: plans are custom-tailored, and you contact sales for pricing. There is no public rate card, no starting price and no per-post rate for Enterprise. Any page that gives you a current Enterprise list price is quoting something other than X.

Reported price: the 2023 figures. The numbers that still circulate come from a March 2023 Wired report, based on a document a Twitter representative sent to prospective academic customers. As summarized by Social Media Today on March 12, 2023, the packages were: 50 million tweets for $42,000 a month, 100 million tweets for $125,000 a month, and 200 million tweets for $210,000 a month. Those were reported, not published, prices, and they predate the 2026 pay-per-usage model.

Reported 2023 packageTweets a monthReported price a monthImplied per 1,000 tweets
First package ("Small", reported in 2023)50 million$42,000$0.84
Second package (reported in 2023)100 million$125,000$1.25
Third package (reported in 2023)200 million$210,000$1.05

How to use those numbers. Treat them as an order of magnitude for what a contract for tens of millions of posts a month was quoted at in 2023, not as today's price. X has changed its self-serve pricing several times since (see the timeline below). The only way to get a current Enterprise number is the sales process, and quotes depend on the endpoints, volume, term and support you ask for.

A useful floor. The one number you can compute from published prices is what the same volume would cost on pay-per-usage if the cap did not exist: 3 million post reads is $15,000. An Enterprise quote buys you volume above that line plus features pay-per-usage does not sell, so it is reasonable to expect an Enterprise conversation to start from that kind of monthly spend.

05 — Section

Cost at 1M, 3M, 10M and 50M tweets a month

Most teams asking about Enterprise do not need the firehose; they need more tweets than 3 million a month from search and timelines. The table prices four common volumes on X's published pay-per-usage rate ($0.005 per post read, from docs.x.com) and on TwitterAPI.io's published rate for tweet endpoints ($0.15 per 1,000 tweets returned). Above 3 million, X has no published price, so the cell says so.

Tweets a monthX pay-per-usageX EnterpriseTwitterAPI.io
1 million$5,000not required$150
3 million$15,000 (cap)not required$450
10 millionnot soldcustom contract$1,500
50 millionnot soldcustom contract (reported $42,000 in 2023)$7,500

The ratio is the rate cards, not a guess. $0.005 per post read is $5.00 per 1,000 posts on X's pay-per-usage card; TwitterAPI.io charges $0.15 per 1,000 tweets returned, so the same read costs about 33x less (5.00 / 0.15 = 33.3). That holds at every volume where X publishes a price. Above the cap the comparison is against an unpublished contract, so we print the reported 2023 figure only as context.

Pay only for the data returned. On our side, tweet endpoints (advanced search, user timelines, mentions, replies, quotes, tweets by ID) charge 15 credits per tweet returned, with a minimum of 15 credits per request, so an empty search costs $0.00015 and a full 20-tweet page costs $0.003. There is no monthly cap and no contract. Profiles are $0.18 per 1,000. Full plan details, including subscriptions, are on the pricing page.

What this comparison does not cover. TwitterAPI.io is not the X firehose. We do not sell a stream of 100% of public posts, likes as events, or X's compliance streams. If your product genuinely needs those, Enterprise is the official route and this table is not your decision. If what you need is search, timelines, mentions, profiles and followers at volume, the table is the decision.

Bar chart of monthly cost: 1M tweets $5,000 on X pay-per-usage vs $150 on TwitterAPI.io; 3M $15,000 vs $450; 10M and 50M are Enterprise-only on X vs $1,500 and $7,500 on TwitterAPI.io
Monthly cost at four volumes from the published rate cards (docs.x.com and TwitterAPI.io, 2026). Above 3M post reads, X sells only a custom Enterprise contract.
06 — Section

What buyers and X's developer channel say about Enterprise (our study)

To see what people actually weigh when they talk about the X Enterprise API, we collected 529 distinct public posts that contain the word "enterprise" together with "x api" or "twitter api", from Latest and Top search orderings, and classified each post with keyword rules (a post can match several themes).

Price dominates. 26.3% of the posts (139) quote a dollar figure. The next most common themes are the monthly cap or volume limits (13.4%), research and academic access (12.3%), and alternatives or scraping (10.8%). Only 6.0% mention the firehose or streams, the feature that is actually exclusive to Enterprise.

The 2023 number refuses to die. 7.8% of posts (41) still cite the $42,000 figure reported in 2023, and 91.9% of the sample was written in 2025 or 2026. Buyers are still anchoring on a reported, three-year-old number that X never published.

Theme in the postShare of postsPostsMedian likes
Quotes a dollar figure26.3%13920
Monthly cap, volume or limits13.4%7115
Research or academic access12.3%6522
Alternatives or scraping10.8%5714
Pay-per-use or credits8.3%4411.0
The reported 2023 $42,000 figure7.8%417
Firehose or streams6.0%327.0
Calls it expensive or costly5.5%2923

What to take from it. If you are evaluating Enterprise, the public conversation will mostly tell you about price and limits, and much of it repeats old numbers. Decide on features first (do you need the firehose, likes streams or Account Activity?) and on volume second (are you above 3 million post reads a month?), then ask X for a quote. Keyword rules are a rough instrument; the shares show what dominates the conversation, not a precise sentiment score.

X's own developer channel. We also read the recent timeline of @XDevelopers, which describes itself as the official source for X developer updates, and the older @API account. Of the 153 own posts we collected from @XDevelopers (reposts excluded), 14 (9.2%) mention Enterprise, pricing or credits. Of 164 posts from @API, whose newest post in our sample dates from 2023, only 2 do; that account mostly announced streaming and platform changes.

The dated @XDevelopers posts give a compact timeline of the self-serve side that sits below Enterprise (dates are the posts' own):

DateWhat @XDevelopers announced
December 14, 2023Users search and Trends lookup endpoints in v2, exclusively on Pro and Enterprise
October 30, 2024Changes to the self-serve X API with new pricing options, limits and annual subscriptions
October 20, 2025Closed beta of the X API pay-per-use model
November 19, 2025News lookup and search endpoints, with extra news access for Enterprise API users
February 6, 2026Official launch of X API pay-per-use, aimed at indie builders, startups and hobbyists
April 16, 2026Changes to pay-per-use, effective April 20
May 21, 2026Legacy Basic plans deprecated; subscribers migrated to pay-per-use after June 1, 2026
October 2, 2026New pay-per-use accounts get free credits on the first card and first auto-recharge

The pattern. The self-serve tier has been rebuilt around pay-per-use, and Enterprise is mentioned mostly as the place where extra or exclusive access lives (Pro and Enterprise endpoints in 2023, extra news access in 2025, a long-standing "Enterprise partner" in a 2026 partner post). X has not used this channel to publish an Enterprise price. That matches the docs: Enterprise is sold, not listed.

Horizontal bar chart: of 529 public posts about the X Enterprise API, 26.3% quote a dollar figure, 13.4% discuss caps or volume, 7.8% cite the $42,000 figure reported in 2023, 6.0% mention firehose or streams
Themes in 529 de-identified public posts about the X Enterprise API, collected in 2026. Keyword classes; a post can match several.
07 — Section

How to get X Enterprise access, step by step

1. Decide whether you need it. Write down which Enterprise-only features you need (firehose or language streams, likes streams, Powerstream, engagement metrics, Account Activity, stream webhooks, more than 1,000 filtered-stream rules) and your expected monthly post reads. If neither list points past pay-per-usage, you do not need a contract yet.

2. Measure your volume before you talk to sales. X asks for expected data volume on the form, and the quote is built around it. Run your real queries for a few hours and extrapolate (the Python script below does this), or use the Usage endpoint on a pay-per-usage app to see your daily post consumption.

3. Submit the interest form. The Enterprise pages link to an access form (docs.x.com/forms/enterprise-api-interest, which forwards to a form on help.x.com). It asks for company details, intended use case, expected data volume and contact information. A sales team follows up to scope volume, endpoints and support.

4. Get a custom quote and negotiate the term. X's pricing page describes committed contracts with longer-term agreements and committed usage levels. Ask for the post-read volume, the endpoints, the rate limits and the support terms to be written into the quote, so you can compare like with like.

5. Onboard. Per docs.x.com/enterprise-api/getting-started/getting-access, you then create a developer app with Enterprise-level access in the Developer Console, your account manager configures rate limits and endpoint access, and you generate keys and tokens (Bearer token for public reads, OAuth 2.0 or OAuth 1.0a for acting as users).

What X does not publish. We could not find a published approval time, a minimum contract value or a minimum term in the docs. Plan for a sales cycle rather than an instant upgrade.

08 — Section

If you do not need the firehose: the pay-per-result path

Many teams who end up on the Enterprise form only need one thing Enterprise sells: more than 3 million posts a month from search, timelines and lookups. For that need, a pay-per-result API is a different trade: no contract and no monthly cap, but also no firehose and no X account manager.

What TwitterAPI.io covers. Read endpoints for advanced search (/twitter/tweet/advanced_search), user timelines (/twitter/user/last_tweets), mentions (/twitter/user/mentions), tweets by ID (/twitter/tweets), profiles (/twitter/user/info) and followers (/twitter/user/followers). Reads need no X account and no developer app approval: you sign up, get a key and call the API.

Price and throughput. Tweets cost $0.15 per 1,000 returned and profiles $0.18 per 1,000; you pay only for the data returned. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days), and purchased credits never expire. Rate limits are 0.2 requests per second before the first payment, 20 once paid, 50 on Scale and 500 on Business, with up to 1,000 on request. Subscriptions run from Starter ($29 a month) to Business ($1,499 a month); details are on the pricing page.

Writes, if you need them. Posting and other actions run through an authenticated session: one /twitter/user_login_v2 login ($0.10, with a proxy you supply) returns login_cookies, then each action such as /twitter/create_tweet_v2 or /twitter/follow_user_v2 costs 60 credits ($0.0006), billed per HTTP 200 call. The call acts as that account, so X can rate-limit, lock or suspend it; keep a normal human pace, expect the session to need a re-login sometimes, and follow X's automation rules.

How to choose. Pick X Enterprise if you need the full public stream, likes or compliance streams, Account Activity webhooks, X's own engagement analytics, or a contract with an X account manager. Pick a pay-per-result API if you need search and timeline reads above 3 million a month, want to start today without a sales cycle, and can build on polling or your own pipelines. Many teams run both: Enterprise for the stream, a pay-per-result API for backfills and ad-hoc research.

python
import os
import requests

BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_KEY"]}

# One page of the newest posts for a query (up to 20 tweets, $0.15 per 1,000 returned)
r = requests.get(
    f"{BASE}/twitter/tweet/advanced_search",
    headers=HEADERS,
    params={"query": "x api enterprise", "queryType": "Latest"},
    timeout=30,
)
r.raise_for_status()
body = r.json()
for t in body.get("tweets", []):
    print(t["createdAt"], t["likeCount"], t["author"]["userName"], t["text"][:80])
print("more pages:", body.get("has_next_page"), body.get("next_cursor", "")[:20])
09 — Section

How we collected this

Question. What do public posts about the X Enterprise API talk about, and how often does X's own developer channel post about Enterprise, pricing or access?

Accounts and queries. Official organization accounts @XDevelopers and @API (own posts, reposts excluded; we confirmed both handles with a profile lookup). Search queries: "enterprise" ("x api" OR "twitter api") in Latest and Top order, and "enterprise api" (twitter OR "x api") (price OR pricing OR cost OR month) in Top order. After de-duplication, 529 posts contained the word "enterprise".

Window and sample. Collected in 2026 through TwitterAPI.io's read endpoints with a rate-limited client: 153 @XDevelopers posts (spanning 2022 to 2026), 164 @API posts (2013 to 2023), and 529 search posts, mostly from 2025 and 2026. The whole study used 73 API requests.

Method. Each post is matched against keyword classes (dollar figures, the $42,000 figure reported in 2023, caps and volume, pay-per-use, firehose and streams, cost complaints, alternatives and scraping, research access). A post can fall into several classes. Shares are of all posts in the sample.

What the sample cannot show. Search results are what the Latest and Top orderings return, not every post ever written; keyword classes miss sarcasm and context; likes favor accounts with large audiences. Nothing here tells you what X quotes in a sales conversation today.

Privacy. Aggregates only. Search authors are mostly private individuals, so we keep no IDs, URLs, text or handles from the search sample; we only report shares (for context, 84.7% of those posts came from accounts with a paid verification badge). Only the two official X organization accounts are named.

python
import os
import time
from datetime import datetime, timedelta, timezone

import requests

BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_KEY"]}

X_PER_POST_READ = 0.005          # docs.x.com pay-per-usage, Posts: Read
X_MONTHLY_CAP = 3_000_000        # pay-per-usage cap; above it X sends you to Enterprise
OURS_PER_1000 = 0.15             # TwitterAPI.io tweet endpoints, per 1,000 tweets returned


def parse_time(s):
    # createdAt looks like "Thu Oct 16 12:34:56 +0000 2026"
    return datetime.strptime(s, "%a %b %d %H:%M:%S %z %Y")


def tweets_in_last_hours(query, hours=6, max_pages=50):
    """Count tweets matching `query` posted in the last `hours` hours (newest first)."""
    cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
    cursor, count, pages = "", 0, 0
    while pages < max_pages:
        r = requests.get(
            f"{BASE}/twitter/tweet/advanced_search",
            headers=HEADERS,
            params={"query": query, "queryType": "Latest", "cursor": cursor},
            timeout=30,
        )
        r.raise_for_status()
        body = r.json()
        pages += 1
        for t in body.get("tweets", []):
            if parse_time(t["createdAt"]) < cutoff:
                return count, pages, True
            count += 1
        if not body.get("has_next_page"):
            return count, pages, True
        cursor = body.get("next_cursor", "")
        time.sleep(0.2)
    return count, pages, False   # stopped early: the real volume is higher


def monthly_estimate(query, hours=6):
    n, pages, complete = tweets_in_last_hours(query, hours)
    per_month = n * (24 / hours) * 30
    x_cost = per_month * X_PER_POST_READ
    ours = per_month / 1000 * OURS_PER_1000
    print(f"{query!r}: {n} tweets in {hours} h ({pages} pages{'' if complete else ', capped'})")
    print(f"  ~{per_month:,.0f} tweets a month")
    if per_month > X_MONTHLY_CAP:
        print("  X pay-per-usage: above the 3M post-read cap -> Enterprise contract (custom price)")
    else:
        print(f"  X pay-per-usage: ~${x_cost:,.0f} a month at $0.005 per post read")
    print(f"  TwitterAPI.io:   ~${ours:,.2f} a month at $0.15 per 1,000 tweets")


if __name__ == "__main__":
    for q in ['"your brand" -filter:retweets', "(openai OR anthropic) lang:en"]:
        monthly_estimate(q)

Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.

10 — Questions

Questions readers ask

How much does the Twitter (X) Enterprise API cost?

X does not publish a price. Its docs say Enterprise plans are custom-tailored to data volume, endpoints and support, and you contact sales for a quote. The figures that circulate are from 2023: Wired reported packages of $42,000 a month for 50 million tweets, $125,000 for 100 million and $210,000 for 200 million. Treat those as historical reports, not a current list price.

When do I need the X Enterprise API instead of pay-per-usage?

When you need more than 3 million post reads in a monthly billing cycle, or a feature that only Enterprise sells: the full firehose or language streams, likes streams, Powerstream, engagement metrics, Account Activity webhooks, stream webhooks or more than 1,000 filtered-stream rules.

What is the X API pay-per-usage cap?

Pay-per-usage plans are capped at 3 million post reads per monthly billing cycle (docs.x.com pricing page). At $0.005 per post read, that is $15,000 of reads. Above it, X directs you to an Enterprise plan.

Does the X Enterprise API include the firehose?

Yes. X's Enterprise introduction lists complete firehose access (100% of public posts in real time), language-specific streams for English, Japanese, Korean and Portuguese posts, and 1% and 10% sampled streams. These volume streams are not available on pay-per-usage.

How do I apply for X Enterprise API access?

Submit the Enterprise interest form linked from docs.x.com with your company details, use case, expected data volume and contact information. A sales team scopes your needs, sends a custom quote and, after signing, an account manager helps you set up an app with Enterprise-level access.

Is there a cheaper alternative to the X Enterprise API for high tweet volumes?

If you need search and timeline reads rather than the firehose, a pay-per-result API like TwitterAPI.io charges $0.15 per 1,000 tweets returned with no contract and no monthly cap, so 10 million tweets a month costs $1,500. It does not replace Enterprise-only streams such as the full firehose or likes streams.

Is the $42,000 a month Enterprise price reported in 2023 still accurate?

We cannot confirm it. The figure comes from a March 2023 Wired report on a document sent to prospective academic customers, and X has rebuilt its self-serve pricing several times since. In our sample of public posts about the Enterprise API, 7.8% still cite it. Only an X sales quote gives a current number.

11 — Further reading

Continue

Sources & further reading
More from this series

Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.

Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key

Already building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.