TweetScout Twitter API is now Sorsa API v3

The TweetScout API is now Sorsa API: it was renamed in 2025, its TweetScout-era v2 has returned 410 Gone since May 1, 2026, and 27 of its 29 calls now run at https://api.sorsa.io/v3.

By the Sorsa API team
Updated Nov 2, 2026
Published Nov 2, 2026
10 min read

Short answer: Moving a TweetScout integration takes four edits: the base URL, handles that leave the path for query parameters, cursor renamed next_cursor, and a few renamed fields. To run the moved calls, use Sorsa API v3: the same ApiKey header, 45 endpoints at 20 requests per second, and 100 free requests to test every old call.

api.sorsa.io/v3; 27 of 29 calls carried over
Price: from $1.40 per 1,000

#What happened to the TweetScout API

The TweetScout API was renamed Sorsa API in 2025 by the team that has run it at Scouts Labs Inc since 2022, and its TweetScout-era version, v2, was retired on May 1, 2026 (opens in a new tab). Every v2 endpoint now returns 410 Gone, and code that still points at api.tweetscout.io/v2 calls that same retired version.

The product split along its two audiences. The crypto analytics app became the Sorsa app at sorsa.io (opens in a new tab), where tweetscout.io and app.tweetscout.io now redirect, and the developer API became Sorsa API at api.sorsa.io. The TweetScout score kept its method under a new name, the Sorsa Score, and its endpoints are part of v3. The Sorsa Score API guide covers the tiers and how the score is built.

Four dates explain every old TweetScout call that fails today: the v2 it was written for was retired on May 1, 2026.

Searches for "Tweet Scout" and "Twitter Scout" lead to the same product. What changed for code is the version: v3 keeps the TweetScout jobs, renames some paths and parameters, and adds 20 endpoints the old API never had, for 45 in total.

#Move a TweetScout call to Sorsa API v3 in four steps

Every TweetScout call moves with the same four edits, and most are one line each. For a TweetScout integration, Sorsa API v3 is the direct successor: 25 v3 paths do the old jobs, the key still goes in the ApiKey header, and every plan runs at 20 requests per second.

Get a v3 key. Sign up and copy a key from API Keys in the dashboard. GET /key-usage-info (opens in a new tab) confirms it works and shows the requests left, and it never counts against them.
Swap the base URL. Replace https://api.tweetscout.io/v2 or https://api.sorsa.io/v2 with https://api.sorsa.io/v3 everywhere in your code.
Move handles and IDs out of the path. TweetScout put the account in the path (/score/{user_handle}, /info-id/{user_id}). v3 takes it as a query parameter: username, user_id or user_link, exactly one of them.
Before: TweetScout API v2 (now 410 Gone)
```
curl "https://api.tweetscout.io/v2/score/orbit_dao_watcher" \
  -H "ApiKey: YOUR_API_KEY"
```
After: Sorsa API v3
```
curl -G "https://api.sorsa.io/v3/score" \
  -H "ApiKey: YOUR_API_KEY" \
  --data-urlencode "username=orbit_dao_watcher"
```
Rename the paging and body keys. cursor becomes next_cursor, link becomes user_link, and user_handle becomes username. In POST /check-follow, project_handle becomes username_1 (the account that should be followed) and user_handle becomes username_2 (the account you check).

The same edits in a script: the base URL changes once, the handle moves into params, and lists that came back as one array in v2 now arrive in pages with a cursor. The Twitter API in Python tutorial covers the rest of the v3 basics.

import requests

BASE = "https://api.sorsa.io/v3"  # was https://api.tweetscout.io/v2
HEADERS = {"ApiKey": "YOUR_API_KEY"}


def score(handle):
    # v2: GET /score/{handle}  ->  v3: GET /score?username=
    r = requests.get(f"{BASE}/score", headers=HEADERS,
                     params={"username": handle}, timeout=30)
    r.raise_for_status()
    return r.json()["score"]


def following(handle):
    # v2 returned one array; v3 pages 200 accounts at a time
    users, cursor = [], None
    while True:
        params = {"username": handle}
        if cursor:
            params["next_cursor"] = cursor
        r = requests.get(f"{BASE}/follows", headers=HEADERS,
                         params=params, timeout=30)
        r.raise_for_status()
        page = r.json()
        users += page["users"]
        cursor = page.get("next_cursor")
        if not cursor:
            return users


print(score("orbit_dao_watcher"))
print(len(following("orbit_dao_watcher")))

const BASE = "https://api.sorsa.io/v3"; // was https://api.tweetscout.io/v2
const HEADERS = { ApiKey: "YOUR_API_KEY" };

async function score(handle) {
  const qs = new URLSearchParams({ username: handle });
  const res = await fetch(`${BASE}/score?${qs}`, { headers: HEADERS });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return (await res.json()).score;
}

async function following(handle) {
  const users = [];
  let cursor = "";
  do {
    const qs = new URLSearchParams({ username: handle });
    if (cursor) qs.set("next_cursor", cursor);
    const res = await fetch(`${BASE}/follows?${qs}`, { headers: HEADERS });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    const page = await res.json();
    users.push(...page.users);
    cursor = page.next_cursor || "";
  } while (cursor);
  return users;
}

console.log(await score("orbit_dao_watcher"));

A 401 means the key is wrong, a 403 means it is missing or out of requests, and a 429 means more than 20 requests in one second, so wait a second and send it again. Score endpoints answer for accounts in the Sorsa Score database, and v3 now names each follower's follow date, as in this GET /top-followers reply:

Response200 OK

{
  "users": [
    {
      "id": "1600000000000000004",
      "username": "lattice_fund_research",
      "display_name": "Lattice Fund Research",
      "followers_count": 48210,
      "followings_count": 612,
      "verified": true,
      "score": 1873,
      "follower_date": "2026-03-14T09:21:07Z"
    }
  ]
}

#The TweetScout API endpoint map, v2 to v3

Of the 29 endpoints in the TweetScout-era v2 reference, 27 carried over to v3 and 2 were retired. The 27 land on 25 v3 paths, because two pairs merged: /info and /info-id became one GET /info, and /score and /score-id became one GET /score.

27 of the 29 TweetScout calls still have a v3 path, and v3 adds 20 endpoints the old API never had.

Paste any old call from your code or logs into the converter to get its v3 request and the edits it needs.

Moved TweetScout GET /v2/score/{user_handle} is now GET /v3/score on Sorsa API.

Sorsa API v3 request

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

Base URL: https://api.tweetscout.io/v2 becomes https://api.sorsa.io/v3.
The handle leaves the path and goes in ?username=; ?user_id= and ?user_link= work too.
One request per account, from $1.40 per 1,000 accounts.

Paste a TweetScout API call, or pick an example, to see the Sorsa API v3 request that replaces it.

The full map lists every v2 call in the old reference's groups, with the v3 path that replaces it and the one edit it needs. Calls whose path didn't change still need the new base URL.

TweetScout API v2	Sorsa API v3	What changes
`GET /info/{user_handle}`	`GET /info`	Handle moves to `?username=`
`GET /info-id/{user_id}`	`GET /info`	ID moves to `?user_id=`
`GET /about`	`GET /about`	`link` becomes `user_link`; `username` also works
`GET /follows`	`GET /follows`	`link` becomes `user_link`; 200 per page with `next_cursor`
`GET /handle-to-id/{user_handle}`	`GET /username-to-id/{user_handle}`	Path renamed
`GET /id-to-handle/{user_id}`	`GET /id-to-username/{user_id}`	Path renamed; reply still holds `handle`
`POST /user-tweets`	`POST /user-tweets`	`link` becomes `user_link`, `cursor` becomes `next_cursor`
`POST /tweet-info`	`POST /tweet-info`	Same body; tweet fields renamed
`POST /tweet-info-bulk`	`POST /tweet-info-bulk`	Same body; reply wrapped in `tweets`
`POST /comments`	`POST /comments`	Optional `order_by`; reply key `comments` becomes `tweets`
`POST /search-tweets`	`POST /search-tweets`	Unchanged
`POST /search-users`	`POST /search-users`	Unchanged
`GET /list-members`	`GET /list-members`	Adds `next_cursor` paging
`GET /list-tweets`	`GET /list-tweets`	`cursor` becomes `next_cursor`
`POST /community-tweets`	`POST /community-tweets`	`cursor` becomes `next_cursor`, `order_by` becomes `order`
`POST /check-member`	`POST /check-community-member`	Path renamed
`POST /check-follow`	`POST /check-follow`	`project_` becomes `_1`, `user_` becomes `_2`
`POST /check-quoted`	`POST /check-quoted`	`user_handle` becomes `username`
`POST /check-retweet`	`POST /check-retweet`	`user_handle` becomes `username`
`GET /check-comment`	`GET /check-comment`	`user_handle` becomes `username`
`GET /score/{user_handle}`	`GET /score`	Handle moves to `?username=`
`GET /score-id/{user_id}`	`GET /score`	ID moves to `?user_id=`
`GET /score-changes`	`GET /score-changes`	`user_handle` becomes `username`
`GET /followers-stats`	`GET /followers-stats`	`user_handle` becomes `username`
`GET /top-followers/{user_handle}`	`GET /top-followers`	Handle moves to `?username=`; `from` dropped
`GET /top-following/{user_handle}`	`GET /top-following`	Handle moves to `?username=`
`GET /new-following-7d`	`GET /new-following-7d`	`user_handle` becomes `username`
`POST /when-follow`	Retired	`POST /check-follow` answers yes or no
`GET /handle-history`	Retired	`GET /about` returns the change count and last date

GET /info/{user_handle}
Sorsa API v3
GET /info
What changes
Handle moves to ?username=
GET /info-id/{user_id}
Sorsa API v3
GET /info
What changes
ID moves to ?user_id=
GET /about
Sorsa API v3
GET /about
What changes
link becomes user_link; username also works
GET /follows
Sorsa API v3
GET /follows
What changes
link becomes user_link; 200 per page with next_cursor
GET /handle-to-id/{user_handle}
Sorsa API v3
GET /username-to-id/{user_handle}
What changes
Path renamed
GET /id-to-handle/{user_id}
Sorsa API v3
GET /id-to-username/{user_id}
What changes
Path renamed; reply still holds handle
POST /user-tweets
Sorsa API v3
POST /user-tweets
What changes
link becomes user_link, cursor becomes next_cursor
POST /tweet-info
Sorsa API v3
POST /tweet-info
What changes
Same body; tweet fields renamed
POST /tweet-info-bulk
Sorsa API v3
POST /tweet-info-bulk
What changes
Same body; reply wrapped in tweets
POST /comments
Sorsa API v3
POST /comments
What changes
Optional order_by; reply key comments becomes tweets
POST /search-tweets
Sorsa API v3
POST /search-tweets
What changes
Unchanged
POST /search-users
Sorsa API v3
POST /search-users
What changes
Unchanged
GET /list-members
Sorsa API v3
GET /list-members
What changes
Adds next_cursor paging
GET /list-tweets
Sorsa API v3
GET /list-tweets
What changes
cursor becomes next_cursor
POST /community-tweets
Sorsa API v3
POST /community-tweets
What changes
cursor becomes next_cursor, order_by becomes order
POST /check-member
Sorsa API v3
POST /check-community-member
What changes
Path renamed
POST /check-follow
Sorsa API v3
POST /check-follow
What changes
project_* becomes *_1, user_* becomes *_2
POST /check-quoted
Sorsa API v3
POST /check-quoted
What changes
user_handle becomes username
POST /check-retweet
Sorsa API v3
POST /check-retweet
What changes
user_handle becomes username
GET /check-comment
Sorsa API v3
GET /check-comment
What changes
user_handle becomes username
GET /score/{user_handle}
Sorsa API v3
GET /score
What changes
Handle moves to ?username=
GET /score-id/{user_id}
Sorsa API v3
GET /score
What changes
ID moves to ?user_id=
GET /score-changes
Sorsa API v3
GET /score-changes
What changes
user_handle becomes username
GET /followers-stats
Sorsa API v3
GET /followers-stats
What changes
user_handle becomes username
GET /top-followers/{user_handle}
Sorsa API v3
GET /top-followers
What changes
Handle moves to ?username=; from dropped
GET /top-following/{user_handle}
Sorsa API v3
GET /top-following
What changes
Handle moves to ?username=
GET /new-following-7d
Sorsa API v3
GET /new-following-7d
What changes
user_handle becomes username
POST /when-follow
Sorsa API v3
Retired
What changes
POST /check-follow answers yes or no
GET /handle-history
Sorsa API v3
Retired
What changes
GET /about returns the change count and last date

The two retired rows still have a route to the same answer, and the section on calls with no one-to-one endpoint below shows it for each.

#Response fields that changed names

v3 replies keep the shape of the TweetScout replies, but 10 field names changed, and lists that v2 returned as bare arrays now come inside an object ({"users": [...]} or {"tweets": [...]}). Parsers break on these renames before anything else, so search your code for the old names first.

TweetScout API v2 field	Sorsa API v3 field	Where it appears
`screen_name`	`username`	Profiles, tweet authors, list members
`name`	`display_name`	Profiles, tweet authors
`friends_count`	`followings_count`	Profiles, tweet authors
`statuses_count`	`tweets_count`	Tweet authors
`register_date`	`created_at`	Profiles
`avatar`	`profile_image_url`	Profiles, tweet authors
`banner`	`profile_background_image_url`	Profiles
`id_str`	`id`	Tweets, tweet authors
`favorite_count`	`likes_count`	Tweets
`in_reply_to_status_id_str`	`in_reply_to_tweet_id`	Tweets

screen_name
Sorsa API v3 field
username
Where it appears
Profiles, tweet authors, list members
name
Sorsa API v3 field
display_name
Where it appears
Profiles, tweet authors
friends_count
Sorsa API v3 field
followings_count
Where it appears
Profiles, tweet authors
statuses_count
Sorsa API v3 field
tweets_count
Where it appears
Tweet authors
register_date
Sorsa API v3 field
created_at
Where it appears
Profiles
avatar
Sorsa API v3 field
profile_image_url
Where it appears
Profiles, tweet authors
banner
Sorsa API v3 field
profile_background_image_url
Where it appears
Profiles
id_str
Sorsa API v3 field
id
Where it appears
Tweets, tweet authors
favorite_count
Sorsa API v3 field
likes_count
Where it appears
Tweets
in_reply_to_status_id_str
Sorsa API v3 field
in_reply_to_tweet_id
Where it appears
Tweets

The camelCase keys of the old top-follower lists (screeName, followersCount, friendsCount, registerDate) became the same snake_case names as every other profile in v3. Fields that kept their names include full_text, retweet_count, reply_count, quote_count, view_count, bookmark_count and can_dm, and each v3 profile adds location, bio_urls, pinned_tweet_ids and protected.

Good to know

The follow date has two spellings in v3: follower_date in GET /top-followers and followerDate in GET /new-followers-7d and GET /new-following-7d. IDs are strings everywhere, as in v2, so keep them as text in your database: long Snowflake IDs lose digits as numbers in JavaScript.

#TweetScout calls with no one-to-one v3 endpoint

Two v2 endpoints were retired, and three things people search for under the TweetScout name were never API endpoints at all. Each still has a v3 route to the same answer.

/when-follow returned the date one account followed another, and only for accounts already in the TweetScout database. In v3, POST /check-follow (opens in a new tab) answers whether the follow exists. For dates, GET /top-followers covers an account's 20 strongest followers, and GET /new-followers-7d (opens in a new tab) lists the crypto accounts that followed in the last 7 days.
/handle-history returned an account's past handles. GET /about (opens in a new tab) returns username_change_count and last_username_change_at, which the free Twitter Username History Checker shows for any account.
"Audience quality" was the TweetScout app's view of who follows an account. In the API it is GET /followers-stats (opens in a new tab), which counts influencers, projects and VC funds among the followers, plus GET /top-followers and GET /score.
A sentiment endpoint never existed in v2 or v3. Pull the posts with POST /search-tweets or POST /mentions and score them with your own model, as in the Twitter sentiment analysis guide.
/v1/analyze on api.tweetscout.io was never a TweetScout endpoint. It turns up in generated trading-bot code, marked there as a hypothetical endpoint, and the address answers 404. For that job, call GET /score and GET /followers-stats.

#What the same key reads now that TweetScout never did

Sorsa API v3 added 20 endpoints the TweetScout API never had, so one key now covers the general X data jobs that crypto dashboards used to buy from a second provider. If your TweetScout integration ran next to another API for follower lists or search, use Sorsa API for both: one key, one bill, and the smart-follower data in the same JSON.

The jobs that sent TweetScout users to a second provider cost this per 1,000 results on Sorsa API, against the official X API's prices (opens in a new tab), which also need a developer account and OAuth and stop at 3 million post reads a month:

Job	Sorsa API endpoint	Sorsa API, per 1,000	Official X API, per 1,000
Full follower lists	`GET /followers`, 200 per page	from $0.007	$10.00
Profiles in batches	`GET /info-batch`, 100 per request	from $0.014	$10.00
Posts by ID	`POST /tweet-info-bulk`, 100 per request	from $0.014	$5.00
Search and mentions, back to 2006	`POST /search-tweets`, `POST /mentions`, about 20 per page	from $0.07	$5.00
Crypto influence score and follower categories	`GET /score`, `GET /followers-stats`, one account per request	from $1.40	not offered

Full follower lists
Sorsa API endpoint
GET /followers, 200 per page
Sorsa API, per 1,000
from $0.007
Official X API, per 1,000
$10.00
Profiles in batches
Sorsa API endpoint
GET /info-batch, 100 per request
Sorsa API, per 1,000
from $0.014
Official X API, per 1,000
$10.00
Posts by ID
Sorsa API endpoint
POST /tweet-info-bulk, 100 per request
Sorsa API, per 1,000
from $0.014
Official X API, per 1,000
$5.00
Search and mentions, back to 2006
Sorsa API endpoint
POST /search-tweets, POST /mentions, about 20 per page
Sorsa API, per 1,000
from $0.07
Official X API, per 1,000
$5.00
Crypto influence score and follower categories
Sorsa API endpoint
GET /score, GET /followers-stats, one account per request
Sorsa API, per 1,000
from $1.40
Official X API, per 1,000
not offered

For KOL and smart-follower tracking, which TweetScout users did in the app, v3 has four calls: GET /top-followers and GET /followers-stats for who backs an account, and GET /new-followers-7d and GET /new-following-7d for the crypto follows of the last week. Full lists of every follower, crypto or not, come from GET /followers (opens in a new tab); the Twitter followers API guide shows the export end to end.

The other new endpoints read quotes, retweeters, a user's replies and retweets, X Articles, Spaces, trends by location, verified followers, list followers, community info, members and search, and the shadowban check. Teams that also read from the official X API can migrate from the Twitter/X API with the same kind of map.

#Move your first TweetScout call today

The TweetScout API lives on as Sorsa API v3: change the base URL, move handles into query parameters, rename cursor, and 27 of the 29 old calls work again. Sorsa API is where to run them: 45 endpoints, the Sorsa Score included, 20 requests per second on every plan, and 100 free requests to convert and test a whole integration before you choose a plan.

#FAQ

Is TweetScout the same as Sorsa API?

Yes. TweetScout was both a crypto analytics app and its developer API, run by Scouts Labs Inc since 2022. In 2025 the app became the Sorsa app at sorsa.io and the API became Sorsa API at api.sorsa.io, with the same team behind both. Sorsa API reads public X data only, never posts, and never asks for your X login, so your X account is never at risk.

Where is the TweetScout API documentation now?

The TweetScout API documentation is now the Sorsa API v3 reference at docs.sorsa.io (opens in a new tab), built from the live OpenAPI file with all 45 endpoints, their parameters and their response fields. The TweetScout-era v2 docs went with v2 on May 1, 2026. The map on this page keeps every v2 path next to the v3 call that replaces it.

Does my old TweetScout API key still work?

Use the key listed under API Keys in your Sorsa API dashboard: that is the key every v3 endpoint accepts, in the same ApiKey header. Any request to a /v2 path fails with 410 Gone whatever the key. If you can no longer open the account that held your TweetScout key, a new account takes a minute and starts with 100 free requests.

Which API should I use instead of the TweetScout API?

Use Sorsa API, the TweetScout API's own successor: 27 of the 29 TweetScout calls carried over, and the Sorsa Score still comes from GET /score. The same key reads full follower lists from $0.007 per 1,000 and posts from $0.014 per 1,000. It runs at 20 requests per second on every plan, with no X developer account and no OAuth.

Can I still get the TweetScout score through the API?

Yes, as the Sorsa Score, the TweetScout score under its new name and with the same method: it counts which crypto influencers, projects and funds follow an account. GET /score (opens in a new tab) returns it for one account per request, and GET /score-changes returns its change over the last week and month. Scores refresh about once a day.

How much does Sorsa API cost for former TweetScout users?

Sorsa API charges one request per call on every endpoint, from $4.90 per 1,000 requests on the Starter plan down to $1.40 on Hyperscale, and failed requests are never charged. Every new account starts with 100 free requests that never expire and need no card, which is enough to convert and test a small TweetScout integration.

#How we checked

On November 2, 2026 we read the TweetScout-era v2 reference file, which api.sorsa.io/v2/swagger.json still serves, next to the live v3 reference. A script matched all 29 v2 endpoints, their parameters and their response fields against v3. We confirmed the v2 retirement date in the Sorsa API docs and the official X API prices on docs.x.com the same day. No API key was used for this article: the requests and the response follow the v3 reference, with demo accounts.

Sources

By the Sorsa API team. We build and run Sorsa API, the read-only Twitter/X API and scraper, in production since 2022 (formerly TweetScout API) with 6B+ requests served. About Sorsa API

What changed

Nov 2, 2026First published.

On this page