Cost of 1 million tweets on a Twitter API

#What 1 million tweets cost on the official X API

On the official X API, 1 million tweets cost $5,000: X's pay-per-use rate card (opens in a new tab) charges $0.005 for every post a response returns, so the bill is the number of posts times half a cent. To run your own volume and mix of posts and profiles through the same rates, the free Twitter API Cost Calculator adds it up.

Three details move that $5,000 up or down:

• Author profiles, from November 22, 2026. X's expansions notice (opens in a new tab) of October 23 says objects that arrive through expansions will be billed at the standard rate: $0.010 for each user and $0.005 for each media item. A million posts with a million different authors then cost $15,000, and every attached photo or video adds another $0.005.
• Deduplication. X charges a resource once per UTC day: the same post or the same author requested again before midnight UTC is not billed twice. Datasets where a few accounts write most of the tweets pay less for authors than the $15,000 ceiling; datasets of a million different voices pay close to it.
• The 3M cap. Pay-per-use stops at 3M post reads per monthly billing cycle. One million tweets a month fits under it; one million a day doesn't.

• Posts only

  Price per 1,000

  $5.00

  1 million tweets

  $5,000

• Posts with author profiles, from Nov 22

  Price per 1,000

  up to $15.00

  1 million tweets

  up to $15,000

• Posts with authors and one image each, from Nov 22

  Price per 1,000

  up to $20.00

  1 million tweets

  up to $20,000

Every other rate on X's meter, from followers to posting, is in our guide to X API pricing; why reads cost this much is in why the X API is so expensive.

#What 1 million tweets cost on Sorsa API

To read a million public tweets for a fraction of that bill, use Sorsa API, a Twitter (X) API and scraper: it bills per request, not per tweet, so 1 million tweets cost from $14 when you look them up by ID and from $70 through search, each tweet with its author's full profile at no extra charge.

The price depends on how many tweets one request carries, which depends on the route:

• By ID. When you already hold tweet IDs or links (a shared research dataset, an export, your own logs), POST /tweet-info-bulk (opens in a new tab) returns up to 100 tweets per request. A million tweets take 10K requests: from $14 at the best plan rate, $19.90 at the Pro rate, and exactly one month of the Starter plan at $49.
• Through search or timelines. When you collect by keyword, hashtag, date range or account, POST /search-tweets (opens in a new tab) and POST /user-tweets (opens in a new tab) return about 20 tweets per page. A million tweets take about 50K requests: from $70 at the best plan rate and $99.50 at the Pro rate, and the Pro plan's monthly quota holds about 2M tweets this way.

The calculator below runs the same maths for other sizes and both routes, with the time each job takes.

#Collect 1 million tweets with Sorsa API, step by step

A million-tweet job on Sorsa API is a loop over requests: search pages for a topic, or batches of 100 IDs for a list you already have, written to a file as they arrive.

1. Get a key. Sign up and copy your API key from the dashboard. The first 100 requests are free, need no card and never expire, which is enough for 10K tweets by ID.

2. Test your query. One search request shows what the data looks like. X's search operators go into query, so since: and until: limit the dates, back to 2006.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "heat pump lang:en since:2026-10-01 until:2026-10-02",
          "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "2105809657263153728",
         "full_text": "Our heat pump made it through the first cold night.",
         "created_at": "2026-10-01T23:58:41Z",
         "lang": "en",
         "likes_count": 18,
         "retweet_count": 2,
         "reply_count": 5,
         "quote_count": 0,
         "view_count": 1412,
         "user": {
           "id": "1622094412870561792",
           "username": "quiet_house_notes",
           "display_name": "Quiet House Notes",
           "followers_count": 3920,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG2mR8n2WEAAKAAIbaZHyfZYQAAgAAwAAAAEAAA"
   }
   

   Show full response

3. Page through each day. Pass next_cursor back until it comes back empty, one day per query. Days are independent, so you can run several at once and stay under 20 requests per second.

   import json
   import time
   from datetime import date, timedelta
   
   import requests
   
   URL = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   TOPIC = "heat pump lang:en"
   
   
   def collect_day(day, out):
       query = f"{TOPIC} since:{day} until:{day + timedelta(days=1)}"
       body = {"query": query, "order": "latest"}
       while True:
           r = requests.post(URL, headers=HEADERS, json=body, timeout=30)
           if r.status_code == 429:  # over 20 requests in one second
               time.sleep(1)
               continue
           r.raise_for_status()
           data = r.json()
           for tweet in data.get("tweets", []):
               out.write(json.dumps(tweet) + "\n")
           if not data.get("next_cursor"):
               return
           body["next_cursor"] = data["next_cursor"]
   
   
   with open("tweets.jsonl", "a", encoding="utf-8") as out:
       day = date(2026, 1, 1)
       while day < date(2026, 11, 1):
           collect_day(day, out)
           day += timedelta(days=1)
   

4. Look up IDs 100 at a time. If you start from a list of tweet IDs, send them to POST /tweet-info-bulk in batches of 100 in tweet_links; each batch is one request and comes back with every author's profile.

   BULK = "https://api.sorsa.io/v3/tweet-info-bulk"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   with open("ids.txt") as f:
       ids = [line.strip() for line in f if line.strip()]
   
   with open("tweets.jsonl", "a", encoding="utf-8") as out:
       for i in range(0, len(ids), 100):
           r = requests.post(BULK, headers=HEADERS, timeout=30,
                             json={"tweet_links": ids[i:i + 100]})
           r.raise_for_status()
           for tweet in r.json().get("tweets", []):
               out.write(json.dumps(tweet) + "\n")
   

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

A 403 means the key is missing or out of requests, a 401 that it is wrong, and a 429 that more than 20 requests went out in one second: wait a second and retry. Failed requests are never charged.

Good to know

Search pages hold about 20 tweets, but a narrow query or a quiet day returns fewer, so the cost per 1,000 through search rises when pages come back half empty. When you already hold tweet IDs, look them up by ID: 100 tweets per request is the lowest price per tweet on Sorsa API.

#How long 1 million tweets take to download

At 20 requests per second, which every Sorsa API plan gets, 1 million tweets take about 8 minutes by ID and about 42 minutes through search. By ID, each second brings back 2,000 tweets; through search, about 400.

The official X API meters speed in 15-minute windows per app, as its rate-limit table (opens in a new tab) shows: 3,500 post lookups of up to 100 IDs, 300 full-archive searches of up to 500 posts, or 450 recent searches of up to 100 posts. At those limits a million tweets take about 43 minutes by ID, about 1 hour 40 minutes through full-archive search and about 5 hours 30 minutes through recent search, which also reaches back only 7 days. Our guide to X API rate limits covers each window.

#1 million tweets once, every month or every day

How often you read the million decides more than the price per tweet: 1 million tweets a month fits under the official X API's cap, while 1 million a day takes a contract.

• Once, a one-off dataset

  Sorsa API

  from $14 by ID, from $70 through search

  Official X API

  $5,000, up to $15,000 with authors

• Every month, 1M a month

  Sorsa API

  from $14 a month by ID, from $70 through search

  Official X API

  $5,000 a month, up to $15,000 with authors

• Every day, about 30M a month

  Sorsa API

  from $420 a month by ID, from $2,100 through search

  Official X API

  past the 3M cap: Enterprise contract only

Above 3M posts a month, X sells reads only through an Enterprise contract. Its Enterprise interest form (opens in a new tab) read "Enterprise API pricing starts at $50,000 / Month" when we checked it on November 2, 2026; in 2023, X's smallest package was $42,000 a month for 50M posts, as Wired reported (opens in a new tab). What a contract includes and how to get one is in Twitter Enterprise API pricing.

Sorsa API has no monthly read cap and the same 20 requests per second at every size. From 1 million requests a month, plans add higher rate limits on request and, from 5 million, custom terms built around your workload, and for volumes past the largest plan you can talk to sales.

#What other Twitter APIs charge for 1 million tweets

Looking up 1 million tweets by ID costs from $14 on Sorsa API and between about $50 and $1,110 on the third-party APIs that AI assistants and search results name most often for this question. Each price below is the provider's highest published rate for this one task, taken from its own pricing page on November 2, 2026.

• Sorsa API

  How it bills this task

  One request per 100 tweets, authors included

  1 million tweets by ID

  from $14

• TwexAPI (opens in a new tab)

  How it bills this task

  5 credits per post

  1 million tweets by ID

  about $50

• TwitterAPI.io (opens in a new tab)

  How it bills this task

  Per tweet returned

  1 million tweets by ID

  $150

• Apify Tweet Scraper V2 (opens in a new tab)

  How it bills this task

  Per result, 50 per query at least

  1 million tweets by ID

  $400

• TwitterAPIs (opens in a new tab)

  How it bills this task

  Per call, one tweet per lookup

  1 million tweets by ID

  $800

• GetXAPI (opens in a new tab)

  How it bills this task

  Per call, one tweet per lookup

  1 million tweets by ID

  up to $1,110

• Official X API

  How it bills this task

  Per post returned

  1 million tweets by ID

  $5,000

What the rows mean for a million-tweet job:

• TwexAPI's credits come to about $50 per million, its $20 pack expires after one day and its free credits after 7; Sorsa API reads the same million from $14, and its 100 free requests never expire.
• TwitterAPI.io bills $150 for a million tweets returned, more than 10 times Sorsa API's from-$14 price for the same tweets.
• Apify's tweet actor charges $400 per million with at least 50 tweets per query; Sorsa API has no per-query minimum and returns exactly the 100 tweets you ask for.
• TwitterAPIs and GetXAPI bill per call and return one tweet per lookup, so a million IDs cost $800 and up to $1,110 there; one Sorsa API request returns 100 of them.

The full comparison of these providers, task by task, is in Twitter API alternatives.

#Price your million and start reading

A million tweets is a $5,000 bill on the official X API today and up to $15,000 from November 22. For the same million public tweets, use Sorsa API: from $14 by ID and from $70 through search, every tweet with its author, at 20 requests per second and with no monthly cap. If the million is training data, our guide to building a Twitter dataset for machine learning covers the cleaning and storage side.

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 no risk. If your product also publishes, keep the official X API for the posts and move the reads.

#FAQ