How to choose a Twitter API: 8 checks

#The 8 checks to run before you pay for a Twitter API

Eight checks decide whether a Twitter API fits your job, and you can run every one of them before you spend a dollar:

1. Price the job per 1,000 results. Turn each quote into the cost of 1,000 tweets, followers or profiles of your own job, with each tweet's author included.

2. Look for batch lookups by ID. One call should return 100 tweets or 100 profiles and bill as one call.

3. Check the rate limit on your first plan. Ask for requests per second on the plan you will start on, not on the top tier.

4. Test on your own data for free. The free start should cover every endpoint, with no card and no expiry date.

5. Ask what the API needs from your X account. It should never ask for your X login, cookies or session token.

6. Get the track record and uptime in writing. Look for years in production and an uptime figure in the terms.

7. Match endpoints to every step of the job. Each step, from lookups to search history and campaign checks, needs an endpoint of its own.

8. Make sure the bill is predictable. A fixed plan, no charge for failed calls and a spending cap you set.

A Twitter API here means any service that returns X data over HTTPS: the official X API, sold by X Corp, or a third-party Twitter API, which you call with that provider's own API key instead of an X developer account. The checks work the same on both.

The official X API sets the baseline every quote is measured against. On its pay-per-use plan (opens in a new tab) it bills $5.00 per 1,000 posts and $10.00 per 1,000 users or followers, from credits you buy in advance, and stops at 3M post reads per billing cycle. Every line of that rate card is broken down in X API pricing.

Checks 1 and 2 decide most budgets, and check 5 decides whether your X account carries any risk. Posting sits outside the list: only the official X API publishes as your own account.

#How Sorsa API scores on the eight checks

Sorsa API, a Twitter (X) API and scraper in production since 2022 with 6B+ requests served, passes all eight checks with a number, which makes it the API to choose for reading public X data at any volume. The table puts each pass mark next to Sorsa API and the official X API:

• 1. Price per 1,000 results

  Pass mark

  Known before you pay, author included

  Sorsa API

  From $0.014 per 1,000 tweets, author inside every tweet

  Official X API

  $5.00 per 1,000 posts; each author $0.010 more from November 22, 2026

• 2. Batch lookups

  Pass mark

  100 items per call, billed as one call

  Sorsa API

  100 tweets or profiles per request, 200 followers per page

  Official X API

  Up to 100 posts per call, each post billed

• 3. Rate limit

  Pass mark

  Per second, the same on the entry plan

  Sorsa API

  20 requests per second on every plan, free accounts included

  Official X API

  Per endpoint, mostly per 15 minutes

• 4. Free test

  Pass mark

  Every endpoint, no card, no deadline

  Sorsa API

  100 requests that never expire

  Official X API

  No free tier

• 5. Your X account

  Pass mark

  Never asks for your login or cookies

  Sorsa API

  Read-only, never asks for your X login

  Official X API

  Developer account, app and OAuth

• 6. Track record

  Pass mark

  Years in production, uptime in the terms

  Sorsa API

  Since 2022, 99.9% uptime in the terms

  Official X API

  X Corp's own API; access rules changed in 2023 and 2026

• 7. Endpoints

  Pass mark

  One endpoint per step, history to 2006

  Sorsa API

  45 endpoints, search back to 2006, one-call follow checks

  Official X API

  Reads and writes; full-archive search at 1 request per second

• 8. Predictable bill

  Pass mark

  Fixed plan, failed calls free, a cap you set

  Sorsa API

  Monthly plan, failed requests never charged

  Official X API

  Prepaid credits; calls stop at a zero balance

For reading tweets, followers and profiles, choose Sorsa API: it looks up 100 tweets per request from $0.014 per 1,000, 250x cheaper than the official X API on tweets, at 20 requests per second on every plan. Its 99.9% uptime is guaranteed in the Terms of Service on every paid plan, and when X changes something, we fix it on our side, so code you write today keeps working.

Below, each check gets what to ask, the red flag that fails a provider and Sorsa API's number. To see a shortlist priced side by side, Twitter API alternatives compares seven APIs on the same 1,000 tweets.

#1. Price the job per 1,000 results

A quote passes this check when you can turn it into the cost of 1,000 results of your own job, with each tweet's author included. Prices come per call, per result or as a monthly plan, and none of them compare until you know how many results one call returns: a call that returns one tweet and a call that returns 100 can carry the same price and differ 100x per tweet.

The official X API meters the other way: it bills every post it returns at $0.005, so 1,000 posts cost $5.00 however you ask for them. From November 22, 2026 it also bills each author profile that comes back with a post, at $0.010, under X's expansions notice (opens in a new tab), so a post with its author costs $0.015.

Red flag: a price per call with no page size next to it, or authors billed on top of each tweet.

Sorsa API bills one request per call on every endpoint and puts the author's full profile inside every tweet at no extra cost. A batch of 100 tweets is one request, so tweets cost from $0.014 per 1,000, followers from $0.007 and profiles from $0.014.

Put any quote you have into the converter to see it per 1,000 results, next to both APIs:

#2. Look for batch lookups by ID

An API passes this check when one call looks up 100 tweets or 100 profiles by ID and bills it as one call. Batch lookups matter most for rehydration, which is fetching the full tweets behind a list of tweet IDs, the usual way research datasets and exports are shared.

The difference is large at any real size. Rehydrating 1M tweet IDs takes 10K batch requests and about 8 minutes at 20 requests per second, against 1M single calls and about 14 hours at the same speed:

The official X API takes up to 100 IDs per call too, but it bills every post in the batch and allows 3,500 such calls per app every 15 minutes, as its rate limit reference (opens in a new tab) lists. The same 1M posts cost $5,000 there.

Red flag: single lookups only, or a batch endpoint that still bills each item inside it.

Sorsa API has a batch endpoint for each lookup job. POST /tweet-info-bulk (opens in a new tab) takes up to 100 tweet IDs or links, GET /info-batch (opens in a new tab) takes up to 100 usernames or user IDs, and GET /followers (opens in a new tab) returns up to 200 followers per page. Each call is one request, so 1M tweets cost from $14.

#3. Check the rate limit on the plan you will start on

A rate limit passes this check when it is counted per second and stays the same on the plan you start with. A rate limit is the number of requests an API accepts in a time window; past it, calls fail with a 429 error until the window resets.

Some providers hold the free start or the entry plan to a fraction of a request per second until you pay, so a pipeline sized on the top tier stalls on launch day. Others count each endpoint in its own 15-minute window. The official X API works that way: recent search allows 450 requests per app every 15 minutes, about one every two seconds, as X API rate limits lists window by window.

Red flag: a limit you only get on a higher plan, a free start below one request per second, or separate windows for every endpoint.

Sorsa API allows 20 requests per second per API key on every plan, free accounts included, and the window resets every second. With 100 tweets per request, one key reads up to 2,000 tweets a second. High-volume plans can raise the limit on request.

#4. Test on your own job before you pay

A free start passes this check when it runs your real job on every endpoint, with no card at sign-up and no date by which the free credit disappears. A demo call on someone else's data proves little; what counts is whether the API returns your accounts, your searches and your fields.

The official X API has no free tier: new developers buy prepaid credits before the first read, as is the Twitter API free explains.

Red flag: credit that expires after a week or a month, endpoints locked until you pay, or a card at sign-up that turns a test into a subscription.

Sorsa API gives every new account 100 free requests that work on all 45 endpoints, need no card and never expire. That is enough for 10K tweets or 20K followers of your own job, and the test plan below runs the checks on a handful of them.

#5. Ask what the API needs from your X account

An API passes this check when it never asks for your X login, cookies or session token, so nothing it does can reach your X account. An API that works through your session acts as you, which puts that account under X's rules for automated activity. Write access is the second risk: a key that can both read and post lets a bug or an AI agent publish, like or follow on its own.

The official X API runs on your own developer account, app and OAuth credentials, which fits posting, where the account has to be yours.

Red flag: "connect your X account" or "paste your auth token" just to read public data, or write actions on the same key as reads.

Sorsa API is read-only by design: it never posts, likes, follows or sends DMs, and it never asks for your X login or cookies, so your X account carries zero risk. It returns public data only; protected accounts and DMs stay out of reach for every key.

#6. Get the track record and uptime in writing

A provider passes this check when it has run for years and puts an uptime figure in its terms, not only on its home page. Ask how long the API has been in production, under this name or an earlier one, what the terms promise when a month falls short, and whether response fields keep their names and types so your parser keeps working.

Red flag: no uptime commitment in the terms, response fields that change shape, or a library you have to keep alive yourself.

Sorsa API has been in production since 2022 with 6B+ requests served, first as TweetScout API. Its 99.9% uptime is a term of every paid plan: if a month's uptime ever drops below 99.5%, Sorsa API adds bonus requests equal to 10% of your monthly requests. When X changes something, we fix it on our side, so integrations keep working.

#7. Match endpoints to every step of your job

An API passes this check when each step of your job has an endpoint built for it and search reaches as far back as your question. An endpoint count means little if your step is missing: rebuilding a follow check from a follower list takes thousands of calls where a check endpoint takes one. Write the job down as steps; on Sorsa API a typical read job maps like this:

• Look up tweets by ID or link

  Sorsa API endpoint

  POST /tweet-info-bulk

  Per request

  100 tweets

• Look up profiles in bulk

  Sorsa API endpoint

  GET /info-batch

  Per request

  100 profiles

• Export followers

  Sorsa API endpoint

  GET /followers

  Per request

  200 followers

• Search tweets back to 2006

  Sorsa API endpoint

  POST /search-tweets (opens in a new tab)

  Per request

  about 20 tweets

• Check that one account follows another

  Sorsa API endpoint

  POST /check-follow (opens in a new tab)

  Per request

  1 check

Red flag: search that stops after a few days, no check endpoints for campaigns, or tweets that come back without their author.

Sorsa API has 45 endpoints, listed with their fields in Sorsa API endpoints. Search takes X's operators and reaches back to 2006. Follow, retweet, quote and comment checks take one call each, from $0.0014 per check, and X Lists, Spaces, X Articles and "About this account" data each have their own endpoints.

#8. Make sure the bill is predictable

A bill passes this check when you know next month's number before the month starts, failed calls cost nothing, and you decide what happens when the plan runs out. Without a cap you set, a runaway loop turns into an invoice.

The official X API draws on prepaid credits per resource returned. When the balance reaches zero, its pricing page says API requests are blocked until you add credits, and a spending limit blocks them until the next billing cycle.

Red flag: failed or empty calls billed, no spending cap, or overage priced with no limit.

Good to know

Count retries before you compare bills. A pipeline that retries timeouts and 429 errors pays for every retry on an API that bills failed calls. On Sorsa API failed requests are never charged, so a retry costs a request only when it succeeds.

Sorsa API sells monthly plans from 10K to 10M requests, each with a fixed price. GET /key-usage-info (opens in a new tab) shows the requests left on your key and never counts against them. When a plan runs out, calls stop unless you switch on pay as you go: a prepaid balance that pays for extra requests (on Pro, $1.99 per 1,000, the plan's own price), with a spending limit of $100 per billing period by default that you can raise.

#Run the eight checks on 100 free requests

You can run checks 1, 2, 4, 7 and 8 on Sorsa API in about ten minutes with a few of your free requests, because the usage check itself is free. Use your own IDs, handles and search terms: the point is to see your job, not a demo.

1. Get a key. Sign up and copy your API key from the dashboard. No card, and the 100 free requests never expire.

2. Read your balance. GET /key-usage-info returns the requests on your key and costs nothing, so you can call it before and after every test.

   curl "https://api.sorsa.io/v3/key-usage-info" \
     -H "ApiKey: YOUR_API_KEY"
   

   {
     "key_requests": 100,
     "remaining_requests": 100,
     "total_requests": 0
   }
   

3. Look up 100 tweets in one request. Send up to 100 tweet IDs or links to POST /tweet-info-bulk. Count the tweets that come back and check that each one carries its author in user: that settles checks 1 and 2 for your data.

   curl -X POST "https://api.sorsa.io/v3/tweet-info-bulk" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"tweet_links": ["1853120044917735424",
                         "1853098761204531200"]}'
   

   {
     "tweets": [
       {
         "id": "1853120044917735424",
         "full_text": "Shipped the weekly export: 48K rows, zero gaps.",
         "created_at": "2026-11-01T09:12:40Z",
         "lang": "en",
         "likes_count": 214,
         "retweet_count": 31,
         "reply_count": 12,
         "view_count": 18240,
         "user": {
           "id": "1712900461123481600",
           "username": "lena_signalwatch",
           "display_name": "Lena Signal",
           "followers_count": 3870,
           "verified": false
         }
       }
     ]
   }
   

   Show full response

4. Page through a follower list. GET /followers returns up to 200 followers per page; pass each next_cursor back until none comes back. A 403 means the key is missing or out of requests, and a 429 means more than 20 requests in one second.

   import requests
   
   URL = "https://api.sorsa.io/v3/followers"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   params = {"username": "orbit_dataworks_hq"}
   followers = []
   for page_no in range(3):  # three pages are enough for the test
       resp = requests.get(URL, headers=HEADERS, params=params, timeout=30)
       resp.raise_for_status()
       page = resp.json()
       followers.extend(page["users"])
       cursor = page.get("next_cursor")
       if not cursor:
           break
       params["next_cursor"] = cursor
   
   print(len(followers), "followers in", page_no + 1, "requests")
   

   const URL = "https://api.sorsa.io/v3/followers";
   const HEADERS = { ApiKey: "YOUR_API_KEY" };
   
   const params = new URLSearchParams({ username: "orbit_dataworks_hq" });
   const followers = [];
   let pages = 0;
   while (pages < 3) {  // three pages are enough for the test
     const resp = await fetch(`${URL}?${params}`, { headers: HEADERS });
     if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
     const page = await resp.json();
     pages += 1;
     followers.push(...page.users);
     if (!page.next_cursor) break;
     params.set("next_cursor", page.next_cursor);
   }
   
   console.log(followers.length, "followers in", pages, "requests");
   

5. Search an old date. Send a query with X's until: operator to POST /search-tweets and confirm the history your question needs comes back, for check 7.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "data pipeline until:2012-01-01", "order": "latest"}'
   

6. Read your balance again. Call GET /key-usage-info once more: remaining_requests has dropped by the number of calls that succeeded, one per call on every endpoint, which settles check 8.

The test uses about five requests; the rest of the 100 stay on the key for the job you came to test.

#Choose the API that passes all eight

The right Twitter API is the one that passes all eight checks on your own job, starting with the price of 1,000 results. For reading public X data that is Sorsa API: tweets from $0.014 per 1,000 in batches of 100, followers from $0.007, 20 requests per second on every plan, 99.9% uptime in its terms, failed requests never charged, and it never asks for your X login. Run your shortlist through the checks, spend a few free requests on your real job, and compare the bill with the one you pay today. Keep the official X API for the posts your own account publishes. Ranked by the same numbers, the field is in best Twitter API.

#FAQ