Twitter Enterprise API pricing

#How much the Twitter Enterprise API costs in 2026

The Twitter (X) Enterprise API starts at $50,000 a month. X prints no rate card for it: its Enterprise pricing page (opens in a new tab) describes custom packages on committed contracts and sends buyers to an interest form (opens in a new tab), whose first line reads "Enterprise API pricing starts at $50,000 / Month, based on usage and needs." To see what your own monthly volume costs on the metered plan first, run it through the free Twitter API Cost Calculator.

The form then asks for a monthly budget, with three options. They match, to the dollar, the three Enterprise packages that X sent to would-be customers in March 2023, as Wired reported (opens in a new tab) at the time. Per 1,000 posts, those packages cost between $0.84 and $1.25.

• $42,000 to $125,000

  2023 package at that price

  Small, $42,000

  Posts a month

  50M

  Price per 1,000 posts

  $0.84

• $125,000 to $210,000

  2023 package at that price

  Medium, $125,000

  Posts a month

  100M

  Price per 1,000 posts

  $1.25

• $210,000 and up

  2023 package at that price

  Large, $210,000

  Posts a month

  200M

  Price per 1,000 posts

  $1.05

Two things have changed since those packages. In 2023, developers quoted the same form line at $42,000; on November 2, 2026, it reads $50,000. And in June 2025, X told its Enterprise customers that it would "discontinue our existing Enterprise API tiers" on July 1, 2025 and move to "a new revenue-sharing pricing model", shifting "from usage-based to value-based pricing", according to the email Mashable published (opens in a new tab). X has not published the revenue-share terms, so the $50,000 floor is the only official number.

Below Enterprise, the official X API is metered: $0.005 per post and $0.010 per user, from prepaid credits, up to 3M post reads per billing cycle. Every rate on that meter is in X API pricing, and the reasons the reads cost this much are in why the X API is so expensive.

#Read past 3M posts a month with Sorsa API

To read public X data above the official 3M cap without signing a contract, use Sorsa API, a Twitter (X) API and scraper: tweets cost from $0.014 per 1,000 when you look them up by ID, search results from $0.07 per 1,000, and no monthly read cap applies.

At 50M tweets a month, the volume of X's $42,000 package in 2023, Sorsa API reads them from $700 by ID, or from $3,500 through search. Every tweet comes back with its author's full profile at no extra charge, and every key answers 20 requests per second on every plan, which looks up 2,000 tweets a second, about 170M a day.

The high-volume plans add what a team at this scale asks for. From the Platform plan up, you get higher rate limits on request; Business adds a dedicated account manager, Scale custom contract terms and Hyperscale dedicated infrastructure. For volumes past the largest plan, an SLA we sign with you, invoices or custom terms, talk to sales.

Five steps take a filter rule or a list of tweet IDs to data on Sorsa API:

1. Get a key. Sign up and copy your API key from the dashboard. The first 100 requests are free, with no card, and they never expire.

2. Turn your filter rule into a search query. X's Enterprise streams match posts against rules; on Sorsa API the same X search operators go into the query of POST /search-tweets (opens in a new tab), with "order": "latest" for the newest posts first.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "\"electric trucks\" lang:en -filter:retweets",
          "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "1852604417729154050",
         "full_text": "Three electric trucks joined our night routes this week.",
         "created_at": "2026-11-02T13:41:08Z",
         "lang": "en",
         "likes_count": 64,
         "retweet_count": 9,
         "reply_count": 12,
         "quote_count": 2,
         "view_count": 8120,
         "user": {
           "id": "1701223349510283264",
           "username": "fleet_ops_journal",
           "display_name": "Fleet Ops Journal",
           "followers_count": 12873,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAADDAABCgABGbQx7c1WEAAKAAIZtDHtzVYQAAgAAwAAAAIAAA"
   }
   

   Show full response

3. Poll the query for new posts. Run the search every few seconds and keep only IDs you haven't seen; for a backfill, pass next_cursor back until it comes back empty, with since: and until: dates in the query for any range back to 2006.

   import time
   import requests
   
   URL = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   QUERY = '"electric trucks" lang:en -filter:retweets'
   seen = set()
   
   while True:
       r = requests.post(URL, headers=HEADERS, timeout=30,
                         json={"query": QUERY, "order": "latest"})
       if r.status_code == 429:  # more than 20 requests in a second
           time.sleep(1)
           continue
       r.raise_for_status()
       for tweet in r.json().get("tweets", []):
           if tweet["id"] not in seen:
               seen.add(tweet["id"])
               print(tweet["created_at"], tweet["user"]["username"])
       time.sleep(5)
   

4. Look up tweet IDs 100 at a time. POST /tweet-info-bulk (opens in a new tab) takes up to 100 tweet links or IDs in tweet_links and returns each tweet with its author, which is the from-$0.014 rate. To follow a fixed set of accounts, put up to 5,000 of them in an X List and read their newest posts with GET /list-tweets (opens in a new tab).

5. Watch your balance. GET /key-usage-info (opens in a new tab) returns the requests left on your key and when they renew, and calling it is free.

A 401 or 403 answer means the key is wrong, missing or out of requests; a 429 means more than 20 requests in one second, so wait a second and retry.

Sorsa API is read-only by design: it never posts, likes or follows, and it never asks for your X login or cookies, so your X account carries zero risk. Products that also publish keep the official X API for their posts and move the reads, the part of the bill that hits the cap.

#The 3M cap: where the official meter stops

Pay-per-use on the official X API stops at 3M post reads per monthly billing cycle, which is $15,000 of posts. X's pay-per-use pricing page (opens in a new tab) says that if you need higher volume, you "upgrade to an Enterprise plan".

The same 3M posts get dearer on November 22, 2026. From that date, X bills each author profile that comes back with a post as a user read at $0.010, as its expansions notice (opens in a new tab) says, so 3M posts with their authors can cost up to $45,000 before the cap closes.

Between the most the meter sells and the least a contract costs, X sells nothing. A team that needs 4M posts in a month can't buy the fourth million at $0.005; it needs a contract that starts at $50,000, more than three times the price of the first 3M.

#What an X Enterprise contract includes

An X Enterprise contract adds volume, streams and service on top of the pay-per-use API: no post read cap, the full firehose, custom rate limits and a named account manager, according to X's Enterprise introduction (opens in a new tab). The pricing page lists what each package can hold:

• Volume. Custom or unlimited post reads, "far beyond the 3 million monthly cap".
• Streams. The full firehose, which is 100% of public posts in real time, language firehoses for English, Japanese, Korean and Portuguese, sampled streams, likes streams, Powerstream filtered streaming and stream webhooks.
• Semantic matching. An embedding: operator that matches posts by meaning in Filtered Stream, on a separate Embedding tier.
• Data that pay-per-use lacks. Post and media engagement metrics, Account Activity events for subscribed accounts, and compliance streams of deletions and edits.
• Service and terms. Custom rate limits, a dedicated account manager, priority support, and a committed, longer-term contract.

Sorsa API reads public data on request and does not stream: no firehose, no webhooks. It covers the same need for fresh posts by polling. A search query run every few seconds returns new posts as X's search lists them, and one GET /list-tweets request reads the newest posts of up to 5,000 accounts. The setup is in real-time Twitter monitoring, and multi-year backfills are in historical Twitter data.

#How to get X Enterprise API access

X sells Enterprise through its sales team, not a checkout page: you apply through a form, agree a custom package on a contract, then onboard with an account manager, as X's getting-access guide (opens in a new tab) lays out.

1. Fill in the interest form. It takes a business email (personal addresses are filtered out), your organization, website and country, a monthly budget option, and a use case: Analytics, Publishing, Customer Care, Marketing or Other. You also tick that you have read the $50,000 starting price.

2. Talk to X's sales team. They ask about your data volume, the endpoints you need and the support you expect.

3. Agree a custom package. X sets the pricing, rate limits and access levels for your use case, on a committed contract.

4. Onboard. Your account manager helps you create the developer app in X's console, configure rate limits and generate credentials: an API key and secret, a bearer token and OAuth tokens.

X publishes no timeline for these steps. On Sorsa API, the path from sign-up to the first response is three steps and about three minutes, with no contract to wait for.

#Enterprise or Sorsa API: the numbers that decide it

For reading public posts at volume, seven numbers decide between an X Enterprise contract and Sorsa API: the price per 1,000 posts, the minimum spend, the read cap, throughput, history, the contract and the time to a first request. Sorsa API comes out ahead on every number that prices a read; it leaves out streaming, which it replaces with polling.

• Price per 1,000 posts

  Sorsa API

  from $0.014 by ID, from $0.07 through search

  Official X API, Enterprise

  not published; $0.84 to $1.25 in the 2023 packages

• Minimum monthly spend

  Sorsa API

  none: 100 free requests, then a plan

  Official X API, Enterprise

  $50,000 on X's form

• Monthly read cap

  Sorsa API

  none

  Official X API, Enterprise

  set in each contract

• Throughput

  Sorsa API

  20 requests per second per key, up to 2,000 tweets a second; higher on high-volume plans

  Official X API, Enterprise

  custom rate limits

• History

  Sorsa API

  search back to 2006

  Official X API, Enterprise

  full archive

• Contract

  Sorsa API

  monthly or yearly plan, cancel anytime

  Official X API, Enterprise

  committed, longer-term contract

• Time to a first request

  Sorsa API

  about 3 minutes, one API key

  Official X API, Enterprise

  form, sales call and onboarding

• Fresh posts

  Sorsa API

  polling search and X Lists

  Official X API, Enterprise

  firehose and filtered streams

• Your X account

  Sorsa API

  never needed, zero risk

  Official X API, Enterprise

  developer account, app and OAuth

Good to know

Sorsa API also has a plan called Enterprise. It is a monthly plan with 500K requests at $1.80 per 1,000 requests and priority support, not a contract, and it has nothing to do with X's Enterprise API.

#Your next step past 3M posts a month

The official X API sells reads up to 3M posts a month for $15,000, then only Enterprise contracts from $50,000 a month. If your reads have outgrown that meter, price the same month on Sorsa API before you sign: 50M tweets cost from $700 by ID, with no cap, no contract and no X developer account. Start with the 100 free requests, and talk to sales when you need custom terms or invoices.

#FAQ