Sorsa Score API: measure crypto influence on X

#What the Sorsa Score measures

The Sorsa Score measures recognition inside crypto X: how many influential crypto accounts follow an account, and how influential those followers are themselves. It began as the TweetScout score in 2022 and kept its method when TweetScout was renamed in 2025.

To see one account's score, type its handle into the free checker on sorsa.io (opens in a new tab), the Sorsa app's home: the score, the tier and the top followers open in seconds. The rest of this page is about reading scores in code, for one account or for thousands.

Four rules decide the number:

• Who follows, not how many. A follow from an account in the Sorsa Score database of crypto influencers, projects and funds adds points. The rest of the audience adds nothing, however large it is.
• Bigger names add more. Each follower's share grows with its own Sorsa Score, so one follow from a leading fund can outweigh dozens from small accounts.
• Farms are filtered out. Follow-for-follow and mass-following accounts are excluded, so traded or bought follows don't move the score.
• Content doesn't count. Posts, likes, replies, giveaways, the blue check and the follower total leave the number where it is.

The Sorsa app reports more than 300K crypto accounts scored and more than 100K tagged as influencers, projects or funds, with data refreshed every day. An account's score moves when a tracked account follows or unfollows it, or when one of its followers gains or loses score.

The official X API has no influence score at all. Building one on it starts with reading an account's followers at $10.00 per 1,000, which is $500 for a single account with 50K followers, before any of them is identified as a fund, a project or an influencer.

#Sorsa Score tiers: what a good score is

What counts as a good Sorsa Score depends on the job: 100 puts an account on the radar of real crypto accounts, 500 makes it Credible, and 2,000 reaches Supreme, the top of crypto X. The scale has no fixed maximum, so the 0–1,000 and 0–5,000 ranges some guides quote are wrong.

The table puts each range next to what an account at that level usually looks like.

• Unknown

  Score

  0–99

  What it means

  No notable crypto followers yet; most new accounts start here

• Noted

  Score

  100–499

  What it means

  Real crypto accounts have started to follow it

• Credible

  Score

  500–999

  What it means

  A solid circle of crypto accounts follows it

• Significant

  Score

  1,000–1,999

  What it means

  Top influencers, projects and funds follow it

• Supreme

  Score

  2,000 and up

  What it means

  Among the most recognized accounts in crypto

The tier is not a field in the API response. GET /score returns the number, and your code maps it to a tier with the five floors above; the code in the next section does it in two lines.

Some crypto campaign and quest platforms admit creators only above a minimum score, such as 300 or 500. When a partner asks for your score, check the exact number it needs, not only the tier.

#Get a Sorsa Score with Sorsa API

Sorsa API, a Twitter (X) API and scraper, returns the Sorsa Score of any public account in one GET request: send a username, a user ID or a profile link, and the number comes back. It needs one API key in a header, with no X developer account and no OAuth, and runs at 20 requests per second on every plan.

1. Get a key. Sign up and copy the API key from the dashboard. Your first 100 requests are free and never expire.

2. Request the score. Send exactly one of username, user_id or user_link to GET /score (opens in a new tab) with the key in the ApiKey header.

   curl -G "https://api.sorsa.io/v3/score" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "username=orbit_labs_protocol"
   

   {
     "score": 1240.4
   }
   

3. Turn the number into a tier. The response holds only score, so the tier comes from the five floors in your own code.

   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   TIERS = [(2000, "Supreme"), (1000, "Significant"),
            (500, "Credible"), (100, "Noted"), (0, "Unknown")]
   
   
   def tier(score):
       return next(name for floor, name in TIERS if score >= floor)
   
   
   def sorsa_score(username):
       r = requests.get(f"{API}/score", headers=HEADERS,
                        params={"username": username}, timeout=60)
       r.raise_for_status()
       return r.json()["score"]
   
   
   score = sorsa_score("orbit_labs_protocol")
   print(score, tier(score))  # 1240.4 Significant
   

   const API = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY" };
   
   const TIERS = [[2000, "Supreme"], [1000, "Significant"],
     [500, "Credible"], [100, "Noted"], [0, "Unknown"]];
   
   const tier = (score) => TIERS.find(([floor]) => score >= floor)[1];
   
   async function sorsaScore(username) {
     const params = new URLSearchParams({ username });
     const res = await fetch(`${API}/score?${params}`, { headers });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     return (await res.json()).score;
   }
   
   const score = await sorsaScore("orbit_labs_protocol");
   console.log(score, tier(score)); // 1240.4 Significant
   

4. Plan for the slow call and the failed one. The first request for a large account the database hasn't indexed yet can take longer, so keep a generous timeout. A 401 means a wrong key, a 403 a missing key or no requests left, and a 429 more than 20 requests in one second: wait a second and retry. Failed requests are never charged.

#What each Sorsa Score endpoint returns

Sorsa API has seven Sorsa Score endpoints. All of them are GET requests, all take one of username, user_id or user_link, and each call costs one request.

• GET /score

  What it returns

  score, one number

  Use it to

  Rank, filter or gate accounts

• GET /score-changes (opens in a new tab)

  What it returns

  week_delta and month_delta

  Use it to

  Spot momentum over 7 and 30 days

• GET /followers-stats (opens in a new tab)

  What it returns

  Counts of influencers, projects and VCs among the followers

  Use it to

  See who backs an account

• GET /top-followers (opens in a new tab)

  What it returns

  The 20 followers with the highest score, each with its own score

  Use it to

  Name the biggest supporters

• GET /top-following (opens in a new tab)

  What it returns

  The 20 highest-scored accounts it follows

  Use it to

  See whose signal it watches

• GET /new-followers-7d (opens in a new tab)

  What it returns

  Tracked accounts that followed it in the last 7 days, with dates

  Use it to

  Catch fresh attention

• GET /new-following-7d (opens in a new tab)

  What it returns

  Tracked accounts it started following in the last 7 days, with dates

  Use it to

  Watch what a fund or KOL just found

GET /followers-stats is the second call most checks need: it shows whether the followers behind a score are individual influencers, project accounts or venture funds and their staff.

{
  "followers_count": 412,
  "influencers_count": 301,
  "projects_count": 88,
  "venture_capitals_count": 23,
  "user_protected": false
}

Good to know

/score-changes and both 7-day endpoints work only for accounts already in the Sorsa Score database, and they see only follows between tracked crypto accounts: they are not a feed of every new follower.

followers_count in /followers-stats counts tracked crypto followers, not the account's X follower total. /top-followers carries each follower's score and follower_date; /top-following returns fuller profiles with followerDate and no score.

For the complete follower list of any account, crypto or not, the Twitter followers API guide covers GET /followers on the same key, 200 followers per request.

#Run a due-diligence check on one account

A due-diligence check on a crypto account takes four requests: the score, its 30-day trend, the mix of followers behind it and the 20 biggest names among them. Together they show whether an account's reach is recognized by people who matter in crypto, or only large.

The script below runs the four calls and prints the report. The trend call raises an error for an account the database hasn't indexed yet, so the script treats a missing trend as "no history" instead of stopping.

# reuses requests, API, HEADERS and tier() from step 3
def get(path, username):
    r = requests.get(f"{API}/{path}", headers=HEADERS,
                     params={"username": username}, timeout=60)
    r.raise_for_status()
    return r.json()


def report(username):
    score = get("score", username)["score"]
    try:
        trend = get("score-changes", username)["month_delta"]
    except requests.HTTPError:
        trend = None  # not indexed yet: no history
    mix = get("followers-stats", username)
    top = get("top-followers", username)["users"]

    flags = []
    if mix["venture_capitals_count"] + mix["projects_count"] == 0:
        flags.append("no tracked fund or project follows it")
    if trend is not None and trend < 0:
        flags.append(f"score fell {trend} in 30 days")

    print(f"{username}: {score:.0f} ({tier(score)})")
    print(f"30-day change: {trend}")
    print(f"Backed by {mix['influencers_count']} influencers, "
          f"{mix['projects_count']} projects, "
          f"{mix['venture_capitals_count']} funds")
    for u in top[:3]:
        print(f"  {u['username']}: {u['score']:.0f}")
    print("Red flags:", "; ".join(flags) or "none")


report("orbit_labs_protocol")

orbit_labs_protocol: 1240 (Significant)
30-day change: 64
Backed by 301 influencers, 88 projects, 23 funds
  halcyon_ventures_x: 2631
  juno_park_research: 1972
  quillswap_official: 1788
Red flags: none

The red flags are yours to set. A launchpad can add a minimum tier, a KOL agency a minimum count of tracked influencers, and a fund a check that its own partners appear in /top-followers.

The score says who backs an account, not whether its audience is real. Bought followers and engagement farms are a separate check on the same key, described step by step in the guide to Twitter bot detection.

#Score a list of accounts and what it costs

To score a list, call GET /score once per account. There is no batch Score endpoint, so 1,000 accounts take 1,000 requests, which finishes in under a minute at 20 requests per second.

import csv
import time
from concurrent.futures import ThreadPoolExecutor


def check(username):
    for _ in range(3):
        r = requests.get(f"{API}/score", headers=HEADERS,
                         params={"username": username}, timeout=60)
        if r.status_code == 429:  # over 20 a second: wait, retry
            time.sleep(1)
            continue
        if not r.ok:
            return [username, "", f"error {r.status_code}", ""]
        s = r.json()["score"]
        return [username, s, tier(s), s >= 500]
    return [username, "", "rate limited", ""]


with open("handles.txt") as f:
    handles = [h.strip().lstrip("@") for h in f if h.strip()]

with ThreadPoolExecutor(max_workers=10) as pool, \
        open("scores.csv", "w", newline="") as out:
    w = csv.writer(out)
    w.writerow(["username", "score", "tier", "credible_or_above"])
    w.writerows(pool.map(check, handles))

The last column gates the list at 500, the Credible floor: change it to the minimum your campaign or allowlist uses. If you show the scores in a public product or on a leaderboard, credit them with "Score by Sorsa" or "Powered by Sorsa" next to the number: public use of the score requires that line.

For scoring crypto accounts in bulk, Sorsa API is the direct route: one key, any public handle, from $1.40 per 1,000 Score checks, and failed requests cost nothing. A check costs your plan's rate per request, so 1,000 Score checks run from $1.40 to $4.90 and 1,000 four-call reports from $5.60 to $19.60; the plans between Pro and Hyperscale fall in that range.

• Starter

  1,000 Score checks

  $4.90

  1,000 four-call reports

  $19.60

• Pro

  1,000 Score checks

  $1.99

  1,000 four-call reports

  $7.96

• Enterprise

  1,000 Score checks

  $1.80

  1,000 four-call reports

  $7.20

• Hyperscale

  1,000 Score checks

  $1.40

  1,000 four-call reports

  $5.60

The planner below turns a list size and the depth of each check into requests, time on one key and cost.

#Moving from the TweetScout API

The TweetScout API is now Sorsa API: the same team and the same Score data, renamed in 2025, with the base URL https://api.sorsa.io/v3. Old tweetscout.io links open the Sorsa app.

TweetScout-era calls move over path by path. A call of the form /v2/score/{handle} becomes GET /v3/score?username={handle}, and /v2/score-changes becomes GET /v3/score-changes. Every v3 Score endpoint takes the account as a query parameter (username, user_id or user_link) and the key in the ApiKey header.

The same key now reads much more than the score: tweets, search back to 2006, profiles in batches of 100 and full follower lists, through 38 more endpoints. A crypto dashboard that showed TweetScout numbers can pull the posts and the audience behind each score from one provider.

#Score your first 100 accounts

The Sorsa Score tells you who backs an X account in crypto, not how loud the account is. To read it in code, use Sorsa API: GET /score for the number, three more calls for the full picture, from $1.40 per 1,000 checks at 20 requests per second, and 100 free requests to score your first 100 accounts today.

#FAQ