TweetScout explained: the crypto Twitter (X) score, its API, and a smart-follower score you can build yourself

- TweetScout is now Sorsa.
tweetscout.io301-redirects tosorsa.io, which describes itself as formerly TweetScout, same team and data. - The score counts who follows, not how many. Follows from known crypto funds, projects and influencers add points; Sorsa does not publish the formula.
- Prices as shown publicly: Sorsa Plus $49/month (no API access); the API is a separate product with plans from $49/month for 10K requests, billed per request.
- DIY version: pick seeds, pull
/twitter/user/followingsfor each, count seed follows per project. Every input is visible and editable. - Our study (collected in 2026): 13 seeds, 28 projects, 5,581 follow edges. Median project: 2 of 13 seeds. Top: ethereum at 6. Two projects scored 0.
- Cost: the whole study was 97 requests and $0.15 at TwitterAPI.io list prices; the same reads on X's pay-per-use rate card would cost $58.91.
If you searched for TweetScout you probably want one of three things: to check a crypto account's score, to call its API from your own code, or to understand what the score actually means before you trust it. This page covers all three, starting with a fact that most write-ups about TweetScout miss: the brand now lives under a new name, and its old domain redirects.
This page is the single-tool explainer. For the wider crypto data landscape, our LunarCrush API guide covers social-sentiment scores, the Data365 alternative page compares general social data vendors, and the developer comparison of Twitter monitoring tools covers alerting. Here we stay on one question: what a smart-follower score is, and how to compute one you can audit, with real numbers from a study of 28 crypto project accounts collected in 2026.
2 of 13 seed funds
What TweetScout is, and why it now redirects to Sorsa
TweetScout started as a crypto-focused Twitter (X) analytics tool. Its pitch, still visible in directory listings of web3 tools, was a single number per account that tried to separate projects with real industry attention from projects with bought or bot followers. Traders used it to vet new token launches, funds used it to spot early projects, and marketers used it to pick influencers.
We checked the domains directly this session. tweetscout.io, app.tweetscout.io and tweetscout.io/pricing each return an HTTP 301 redirect to sorsa.io, and api.tweetscout.io now serves a page whose title and canonical URL belong to the Sorsa API at api.sorsa.io. The Sorsa home page describes the product as formerly known as TweetScout and its FAQ says it is the same team and data under a new name. So when people search for the TweetScout score or the TweetScout API in 2026, the live product they reach is Sorsa.
What that means for you. Bookmarks and old API base URLs from TweetScout tutorials may still resolve through redirects, but documentation, pricing and endpoint paths now live under the new brand. If you maintain code that called the old API, read the current docs before assuming paths or headers are unchanged.
How the TweetScout (Sorsa) score and smart followers are described
In its own words, the score "counts who follows an account, not how many." Follows from influential crypto accounts add points, while follow-for-follow and bot accounts are excluded. Scores fall into named tiers that run from Unknown (0 to 99) up to Supreme (2,000 and above). Its API docs describe the score as popularity among influencers, projects and VCs.
The smart-followers list is the other half of the product: in Sorsa's words, "every KOL, project and fund that follows, with its own Score." The free tier shows counts; the paid Plus plan unlocks the full lists, plus bot-follower checks and score history.
What is not public. Neither the marketing site nor the API docs we read document the formula: which accounts count as influential, how much each one weighs, or how bots are classified. That is a normal choice for a commercial product, and it is also the main reason developers look for an alternative: you cannot explain to a stakeholder why a project scored 412 rather than 600, and you cannot change the definition of a smart follower for your niche.
The underlying idea is simple and old. Scoring a node by who links to it, weighted by the links' own standing, is the idea behind citation analysis and PageRank. For X, the link is a follow. The hard parts are choosing the seed accounts and collecting follow graphs at a reasonable cost, and both are things you can do yourself.
TweetScout API endpoints and price, as shown publicly
The current API docs (base https://api.sorsa.io/v3, key sent in an ApiKey header) list score and follower endpoints including /score, /score-changes, /followers-stats (followers by category), /top-followers and /top-following (ranked by score), /new-followers-7d and /new-following-7d, plus profile lookups /info and /info-batch (up to 100 users). There is no endpoint literally named smart followers; the closest are the category breakdown and the ranked top-followers list.
Pricing, as shown on the vendor's pages this session, in US dollars:
Higher API plans run up to $13,990/month for 10M requests, and the pricing page lists a rate limit of 20 requests per second per key. The point to note for a developer is the billing model: a monthly plan with a request quota, billed per request whether or not you use the whole quota. With TwitterAPI.io you do not need a monthly plan to start: you pay only for the data returned, and the follow-graph reads in the study below cost $0.15 in total.
Build a smart-follower score yourself: the method
A do-it-yourself smart-follower score has four steps, and each one maps to a public X data endpoint:
1. Choose the seed set. These are the accounts whose follows you treat as a signal: funds, research desks, media, core developers of the ecosystems you care about. This is where your judgment goes, and it is the step a closed score hides from you.
2. Pull each seed's followings. /twitter/user/followings with userName=<seed> returns the accounts that seed follows, up to 200 per page with has_next_page and next_cursor for paging. Seeds are usually organizations that follow a few hundred to a few thousand accounts, so a seed costs one to ten requests.
3. Count overlaps. For each project, the score is the number of seeds whose followings list contains it. You can weight seeds (a fund that follows 49 accounts is more selective than a media desk that follows 1,814) or normalize by follower count, but the raw count is already informative and fully explainable.
4. Sanity-check against activity. /twitter/user/last_tweets returns a project's recent posts with like, repost, reply, quote and view counts, plus the author's follower count. That lets you ask whether a high score goes with real engagement, or whether the two measure different things.
Why followings of the seeds rather than followers of the projects? A large project has millions of followers; paging through all of them to find 13 seeds would take thousands of requests. A seed's followings list is short. Reversing the direction turns a 4.5-million-row problem into a 5,581-row one.
The study: 28 crypto projects against 13 seed organizations
We ran the method on 28 well-known crypto project accounts (chains, scaling networks, DeFi apps, wallets and exchanges) and 13 seed organizations (venture funds, a research firm and a news outlet). The 13 seeds follow 5,581 accounts in total. The table shows the top five and bottom five projects by seed overlap.
No project reached half of the seeds. The maximum was 6 of 13 (ethereum) and the median was 2. Two well-known scaling networks, arbitrum and Starknet, were followed by none of the 13 seeds. That does not mean the funds ignore them; it means following is a sparse, noisy signal, and a score built on a handful of seeds will be lumpy.
Overlap tracks size more than engagement. Across the 28 projects the Spearman rank correlation between seed overlap and follower count was 0.449, while overlap against median engagement rate was -0.219. Big accounts collect follows from everyone, funds included. Engagement rate falls as accounts grow (followers vs engagement: -0.411), the usual pattern for large accounts.
Normalizing changes the leaderboard. Divide overlap by millions of followers and the smaller projects rise: LidoFinance scores 13.2 seed follows per million followers and celestia 11.09, against 0.19 for binance. Which version you want depends on the question: absolute industry attention, or attention relative to audience size. A closed score makes that choice for you.

What the seed set does to the score
Seeds are not equal. A seed that follows thousands of accounts contributes many overlaps; a seed that follows a few dozen contributes almost none. In our study the spread was wide:
CoinDesk alone accounts for 17 of the project follows because it follows 1,814 accounts; Jump Crypto (jump_) follows 49 accounts and none of the 28 projects. Across the 13 seeds, the 5,581 follows point at 4,517 distinct accounts, and 83.9% of those are followed by just one seed. Only 17 accounts are followed by five or more.
Practical rules for a seed set. Use more seeds than you think (30 to 100 gives a smoother distribution than 13). Mix selective seeds (few follows) with broad ones, and consider weighting each seed's follow by one over the log of its followings count so a broad follower does not dominate. Remove seeds that follow almost nothing in your target space. Re-pull seed followings on a schedule, because follow lists change: the followings list comes back most recent follow first, so you can also diff it to spot new follows early, which is the idea behind new-follower feeds.

Engagement as a second signal
The median engagement rate across the 28 projects, measured as (likes + reposts + replies + quotes) divided by views on each project's recent original posts, was 1.058%. The large exchanges sat at the bottom (binance 0.252%, coinbase 0.304%, okx 0.319%), while Aptos (2.225%), Starknet (2.0%) and chainlink (1.964%) were at the top.
Why combine the two. Seed overlap answers whether the industry is watching; engagement answers whether the audience responds. A project with high overlap and low engagement has attention it is not converting; a project with zero overlap and high engagement, like Starknet in our sample, has an audience the seed set does not capture. Either one alone gives you half the picture, which is a good argument for computing both from raw data instead of reading a single opaque number.
Bot-heavy audiences. A closed score also tries to discount bot followers. You can approach that from the other side with signals the API returns on every profile: account age (created_at), follower-to-following ratio, statuses_count, default profile images and isAutomated on batch lookups. Treat these as tells, not verdicts.
Cost: what the study cost and what the same reads cost on X
Every request in the study is accounted for. The 13 seed followings lists took 35 pages at pageSize=200 (1 credit per account returned at that page size, 60-credit minimum per call), 28 project timelines took one last_tweets page each (15 credits per tweet returned), and the profile lookups were 18 credits each. Four lookups for renamed or unknown handles are included in the request count.
The official X API comparison. On X's pay-per-usage rate card (docs.x.com/x-api/getting-started/pricing), a following/followers read is $0.010 per resource, a user read $0.010 and a post read $0.005. The same 5,581 follow reads, 30 user reads and 560 post reads come to $58.91. On the per-1,000-tweet axis alone the gap is $5 per 1,000 posts on X's rate card versus $0.15 per 1,000 tweets with TwitterAPI.io, about 33x.
Scaling up. A seed set of 100 organizations averaging 500 follows each is 50,000 follow reads, about 250 pages and roughly $0.50 at 1 credit per account. Re-pulling it weekly to catch new follows costs the same again each week. Reads need no X account and no developer approval; new accounts that pass the automatic bot check start with up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days), which covers a study of this size several times over.
How we collected this
Question. Can a transparent smart-follower score be rebuilt from public follow graphs, and how does it relate to follower count and engagement for well-known crypto projects?
Accounts. Seeds (13 organizations): paradigm, PanteraCapital, ElectricCapital, yzilabs, jump_, variantfund, Delphi_Digital, galaxyhq, 1kxnetwork, DCGco, frameworkvc, robotventures, CoinDesk. Projects (28 organizations): ethereum, solana, arbitrum, Optimism, base, avax, Aptos, SuiNetwork, celestia, Uniswap, aave, chainlink, LidoFinance, eigencloud, Polymarket, opensea, MetaMask, phantom, Ledger, krakenfx, coinbase, binance, okx, Starknet, NEARProtocol, cosmos, 0xPolygon, HyperliquidX.
Window and sample. Complete followings lists of each seed at collection time (5,581 follow edges); each project's most recent page of posts (560 posts, of which reposts and posts without a view count were excluded from engagement). Collected in 2026 with /twitter/user/info, /twitter/user/followings and /twitter/user/last_tweets, 97 requests.
What the sample cannot show. Thirteen seeds is a small panel and our seed choice is a judgment call; a different seed set would reorder the projects. Engagement medians for ethereum, aave and eigencloud rest on two or three original posts because their recent pages were mostly reposts. Correlations across 28 accounts are descriptive, not causal. We did not try to reproduce any vendor's score values.
Privacy. Seeds and projects are organization accounts. Seed followings lists include private individuals, so raw pages were kept out of the published study; only counts and organization names appear here.
import time
import requests
API_KEY = "YOUR_TWITTERAPI_IO_KEY"
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": API_KEY}
# 1. Your seed set: accounts whose follows you treat as a signal (funds, researchers, media).
SEEDS = ["paradigm", "PanteraCapital", "ElectricCapital", "variantfund", "Delphi_Digital", "CoinDesk"]
# 2. The accounts you want to score.
PROJECTS = ["ethereum", "solana", "celestia", "LidoFinance", "Starknet", "HyperliquidX"]
def followings(user_name, max_pages=20):
"""Every account `user_name` follows (screen_name, lowercased), 200 per page."""
names, cursor = set(), ""
for _ in range(max_pages):
r = requests.get(
f"{BASE}/twitter/user/followings",
headers=HEADERS,
params={"userName": user_name, "cursor": cursor, "pageSize": 200},
timeout=40,
)
r.raise_for_status()
body = r.json()
if body.get("status") != "success":
raise RuntimeError(f"{user_name}: {body.get('msg')}")
for u in body.get("followings", []):
names.add(u["screen_name"].lower())
if not body.get("has_next_page"):
break
cursor = body["next_cursor"]
time.sleep(0.2)
return names
def engagement(user_name):
"""Median (likes + reposts + replies + quotes) / views over recent original posts."""
r = requests.get(
f"{BASE}/twitter/user/last_tweets",
headers=HEADERS,
params={"userName": user_name},
timeout=40,
)
r.raise_for_status()
tweets = (r.json().get("data") or {}).get("tweets", [])
rates, followers = [], None
for t in tweets:
author = t.get("author") or {}
if author.get("userName", "").lower() != user_name.lower():
continue # skip reposts of other accounts
followers = author.get("followers")
if t.get("retweeted_tweet") or not t.get("viewCount"):
continue
hits = t["likeCount"] + t["retweetCount"] + t["replyCount"] + t["quoteCount"]
rates.append(hits / t["viewCount"])
rates.sort()
median = rates[len(rates) // 2] if rates else None
return followers, median, len(rates)
seed_graph = {s: followings(s) for s in SEEDS}
print(f"{'project':<14}{'followers':>12}{'seeds':>8}{'median ER':>11}{'posts':>7}")
for p in PROJECTS:
who = [s for s, follows in seed_graph.items() if p.lower() in follows]
followers, er, n = engagement(p)
er_txt = f"{er * 100:.2f}%" if er is not None else "n/a"
print(f"{p:<14}{followers or 0:>12,}{len(who):>5}/{len(SEEDS):<2}{er_txt:>11}{n:>7} {', '.join(who)}")
Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.
Questions readers ask
Is TweetScout still working?
The TweetScout brand has moved. In 2026 tweetscout.io, app.tweetscout.io and the old pricing path return a 301 redirect to sorsa.io, and the Sorsa site describes itself as formerly TweetScout with the same team and data. Score checks and smart-follower lists are offered there.
How is the TweetScout score calculated?
As the vendor describes it, the score counts who follows an account rather than how many: follows from influential crypto accounts add points and bot or follow-for-follow accounts are excluded, with tiers from Unknown (0 to 99) to Supreme (2,000 and above). The exact formula and the list of weighted accounts are not published.
Why is my TweetScout score zero?
Because the score only counts follows from accounts the vendor treats as influential, a new or niche account that none of them follow scores zero no matter how many followers it has. In our own seed study, two well-known scaling networks were followed by none of 13 crypto fund and media seeds, which shows how sparse these follow signals are.
Does TweetScout have an API, and what does it cost?
Yes, now under the Sorsa name. The docs list endpoints such as /score, /followers-stats, /top-followers and /new-followers-7d at api.sorsa.io/v3 with an ApiKey header. The pricing page shows plans from $49/month for 10K requests, billed per request, and 100 free trial requests. The consumer Plus plan ($49/month) does not include API access.
What are smart followers on crypto Twitter?
Smart followers are the followers of an account that belong to a chosen set of respected accounts: funds, builders, researchers, well-known projects. The count is used as a signal of industry attention that is harder to fake than raw follower numbers, because buying followers does not buy follows from those accounts.
How do I build a TweetScout alternative with an API?
Choose a seed set of accounts you trust, pull each seed's followings with /twitter/user/followings (200 per page, next_cursor paging), and count how many seeds follow each project. Add engagement from /twitter/user/last_tweets as a second signal. The Python example on this page does both; our 28-project study cost $0.15 in total.
How much does it cost to pull follower and following lists from X?
On X's official pay-per-usage rate card a following/followers read is $0.010 per resource. With TwitterAPI.io followers and followings cost 1 to 3 credits per account returned depending on page size (1 credit at 200 per page), and 100,000 credits is $1. Purchased credits never expire.
Can I get the full follower list of a big project like binance?
Yes, by paging /twitter/user/followers, but a 16-million-follower account means tens of thousands of pages. For a smart-follower score it is far cheaper to page the followings of your seed accounts and look for the project there, which is the direction this page uses.
Continue
- TwitterAPI.io docs: GET /twitter/user/followings (pageSize 20-200, per-page credit tiers)
- TwitterAPI.io docs: GET /twitter/user/last_tweets
- X API pricing: pay-per-usage rate card (post, user and following/followers reads)
- X API docs: get the accounts a user follows
- PageRank: scoring nodes by who links to them
- Spearman's rank correlation coefficient
- X (Twitter) API overview: endpoints, access and pricing
- LunarCrush API: crypto social metrics and how to get them
- Data365 alternative for X data
- Using AI and X data for crypto trading signals
- Twitter monitoring tools compared for developers
- Free tool: check whether one X account follows another
- TwitterAPI.io pricing: pay per tweet and per profile returned
- 01Most Mentioned Stocks and Crypto on Twitter (X): 81.3 Million Cashtag Mentions, 2024-2026
- 02Twitter (X) Images Not Loading: A Five-Hop Fix Checklist
- 03X Premium in 2026: The X Subscription Tiers, What They Unlock, and How to Cancel
- 04Twitter (X) Ads Library: What the X Ads Repository Shows, and What It Misses
- 05Twitter (X) Spaces API: Official Endpoints, Space Details and Real Listener Data
- 06Twitter (X) Clients in 2026: Which Ones Still Work, by Platform
- 07Twitter (X) Tweet Metadata — API Fields Reference
- 08What Was Twitter (X) Circle, and What Can You Use Instead?
Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API keyAlready building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.