How to Check If Someone Follows You on Twitter (X)

By Sorsa Editorial

Updated June 2026: rewritten to reflect the official X API's current follow-relationship limits, refreshed the manual steps for the latest X profile layout, and added an API method for bulk and automated checks.

The annoying part is that X never built a clean way to ask "does this account follow that one?" There is no button for it. You either scroll a follower or following list hoping a username turns up, or you lean on the small "Follows you" badge that only appears when someone follows the account you are logged into. For one check that is fine. The moment you need to verify follows in volume, for a campaign verification workflow, a partnership audit, or a feature inside your own app, the manual route falls apart.

That gap is the reason we built Sorsa API, an alternative Twitter/X API provider. Our /check-follow endpoint answers "does account B follow account A?" for any two public profiles in a single request, returning a plain true or false in roughly 300ms, with no OAuth dance and no need to authenticate as either user. Every plan runs on a flat 20 requests per second, access is instant with no approval queue, and a follow check is one flat request rather than a pile of per-user reads. For a one-off lookup you do not even need the API: our free Twitter follow checker returns the answer in the browser. This guide covers every method, from the manual tap-through to a Python loop that verifies thousands of relationships an hour.

Table of Contents

• Check follows manually on X
• Do free Twitter follow checker tools still work?
• Check follow relationships with an API
• How to check if two accounts follow each other
• Checking follows at scale
• Which method should you use?
• FAQ
• Getting started

Check follows manually on X

To check a follow relationship by hand, open the profile of the account you think is doing the following, tap Following, and use the in-list search to look up the other account's handle. If it appears, the follow exists. To confirm someone follows you specifically, open your own Followers list and search there, or look for the "Follows you" badge under their name when you visit their profile.

The native approach needs no tools, no keys, and no third-party access, and it works in both directions if you do it carefully.

To check whether a specific account follows you:

1. Open your own profile on X (x.com or the mobile app).
2. Tap Followers.
3. Type the username into the search box at the top of the list.
4. If they show up, they follow you. If the search comes back empty, they do not.

To check whether account A follows account B (when neither is you):

1. Open account A's profile, the one you suspect is doing the following.
2. Tap Following.
3. Search that list for account B's handle.

There are two visual shortcuts worth knowing. When you visit a profile that follows you, X shows a "Follows you" badge next to the handle. And when you open a profile that several accounts you already follow also follow, X surfaces a "Followed by ..." line under the bio. Both are quick signals, but neither answers an arbitrary "does A follow B" question between two accounts you have no relationship with.

The manual method has a real limit we keep running into: the in-list search only queries the slice of the list your browser has already loaded. X pulls follower and following lists in chunks, so for an account with hundreds of thousands of follows, a search can miss a handle that simply has not loaded yet. For small accounts it is reliable. For large ones, a negative result is not proof of a non-follow. That is the point where you stop tapping and switch to a tool or an API.

Do free Twitter follow checker tools still work?

Some free Twitter follow checker tools still work, but many single-purpose ones broke after X restricted unofficial data access in 2023. Browser checkers backed by a real data source can still return a quick yes or no, while older tools that relied on scraping or open API access often fail silently, throw errors, or return nothing. Reliability is hit or miss, so the surviving option is a checker that runs on its own data pipeline.

If you search for "twitter follow checker," you will hit a cluster of free web tools that promise a one-field answer to "does A follow B?" The best known single-purpose tool, HackTrix, has held top rankings for years, but the category as a whole is inconsistent: the simple checkers that depended on free Twitter API access lost their data source when that access was cut and paid tiers replaced it.

The larger names you will see, such as Circleboom and Audiense Connect, are full management and analytics platforms rather than follow checkers. They can show follower relationships, but they require you to sign in and authorize an account, and signing up for a social-media suite is overkill when all you want is a single boolean answer.

For a quick check that does not break, we keep a free browser follow checker on our site. It runs against our own infrastructure rather than scraping X directly, so it does not hit your account's rate limits or trip an automation flag, and it needs no login. Enter two handles, read the result. When you need that same answer repeatedly or inside software, the API method below is the next step up.

Check follow relationships with an API

The official X API has no simple call for "does one arbitrary account follow another." Its v2 connection_status field returns following and followed-by status, but only for the account you authenticate as, and only on higher paid access tiers. To check any other pair, you have to page through one side's complete follower or following list and search it, which is slow and costly for large accounts. A purpose-built verification endpoint answers the question directly in one request.

You can confirm the limitation in the official X API follows documentation: the relationship lookup is scoped to the authenticating user, and on the official API the follow and following endpoints sit behind paid tiers. So the moment you want to know whether @alice follows @bob when you control neither account, the official API pushes you toward enumerating a full list at a per-user read cost.

Sorsa API closes that gap with a single endpoint. Send two identifiers, get back true or false, for any two public accounts, authenticated with one API key in a header rather than an OAuth flow.

Quick check (cURL)

curl -X POST https://api.sorsa.io/v3/check-follow \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "username_1": "TargetAccount",
    "username_2": "PossibleFollower"
  }'

Response:

{
  "follow": true,
  "user_protected": false
}

The logic reads as "does username_2 follow username_1?" When follow is true, the second account follows the first. The user_protected field flags a private account, where follow data cannot be read by anyone outside the approved follower list.

Python

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.sorsa.io/v3"

def check_follow(target: str, possible_follower: str) -> bool:
    """Check whether possible_follower follows target. Returns True or False."""
    resp = requests.post(
        f"{BASE_URL}/check-follow",
        headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
        json={
            "username_1": target,
            "username_2": possible_follower,
        },
    )
    resp.raise_for_status()
    return resp.json().get("follow", False)

follows = check_follow("YourBrand", "some_user")
print(f"Follows: {follows}")

You can pass a username, a numeric user ID, or a full profile URL, whichever your data already holds. Full parameter details live in the endpoint reference.

On cost, the difference is structural, not marginal. Sorsa uses flat per-request pricing: one follow check is one request, which works out to about $0.00199 on the Pro plan ($199 for 100,000 requests) and around $0.0018 on Enterprise. On the official API, verifying a follow against a large account means paging its follower list at roughly $0.010 per user read, so a single answer can cost dollars in reads before you find the handle, if you find it at all. One flat request against one boolean is the cheaper unit by a wide margin.

How to check if two accounts follow each other

No API or tool returns mutual-follow status in a single call, because a "mutual follow" is two separate one-directional follows. To confirm two accounts follow each other, you run two checks: does A follow B, and does B follow A. If both come back true, the relationship is mutual.

def check_mutual_follow(user_a: str, user_b: str) -> dict:
    """Check whether two accounts follow each other."""
    a_follows_b = check_follow(target=user_b, possible_follower=user_a)
    b_follows_a = check_follow(target=user_a, possible_follower=user_b)

    if a_follows_b and b_follows_a:
        relationship = "mutual"
    elif a_follows_b:
        relationship = "one_way_a_to_b"
    elif b_follows_a:
        relationship = "one_way_b_to_a"
    else:
        relationship = "none"

    return {
        "a_follows_b": a_follows_b,
        "b_follows_a": b_follows_a,
        "relationship": relationship,
    }

result = check_mutual_follow("user_one", "user_two")
print(result)
# {'a_follows_b': True, 'b_follows_a': False, 'relationship': 'one_way_a_to_b'}

Two calls, two requests from your quota, under a second end to end. The same pattern scales to checking which accounts in a list mutually follow a given account by looping the second handle.

Checking follows at scale

At scale, the manual method and broken free tools stop being options, and the API becomes the only practical path. To verify follows across hundreds or thousands of accounts, loop a follow-check call per account and write the results to a file. At a flat 20 requests per second, that clears roughly 72,000 checks an hour, with each result a clean boolean you can act on.

Here is the batch pattern:

import time
import csv

def verify_followers_batch(brand: str, usernames: list, output_file: str = "results.csv"):
    """Verify whether a list of accounts follow a specific account."""
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["username", "follows"])

        for i, username in enumerate(usernames):
            follows = check_follow(brand, username)
            writer.writerow([username, follows])

            if (i + 1) % 100 == 0:
                print(f"Checked {i + 1}/{len(usernames)}")

            time.sleep(0.05)  # stay within the 20 req/s rate limit

    print(f"Done. Results saved to {output_file}")

participants = ["user1", "user2", "user3"]  # load from your participant list
verify_followers_batch("YourBrand", participants)

The 20 requests per second rate limit is the same on every plan and can be raised for high-volume work by contacting sales. Campaigns that gate on more than one action can mix the follow check with the other verification endpoints: /check-follow, /check-retweet, /check-comment, /check-quoted, and /check-community-member, each a single boolean call. The full campaign verification guide covers wiring these together.

In practice. A Web3 gaming studio we worked with ran a token-launch giveaway campaign that required entrants to follow the main account, repost the announcement, and join its X Community. They had about 8,400 entries. Before automating, a community manager was spot-checking entries by hand for two days and still only got through a fraction of them, and the unchecked remainder was exactly where the throwaway and bot accounts hid, many of which had unfollowed the moment they took the screenshot. Wiring the three checks into a script, they verified all 8,400 entrants across the three tasks in under an hour for roughly $50 on the Pro plan, and every single entry was confirmed programmatically instead of sampled. That is the difference flat per-request pricing makes: the cost scales with checks, not with the size of any account's follower list.

Which method should you use?

If you just want to know whether a friend followed you back, open X and look for the "Follows you" badge. For a fast one-off without any setup, the free follow checker covers it. For anything programmatic, a campaign, a bot, a dashboard, an analytics feature, an API is the only method that stays accurate and fast as volume grows.

FAQ

Can I check if someone follows me on X without them knowing?

Yes. Checking a follower or following list on X is a passive, read-only action, and the other account is never notified. This holds whether you check manually on X, through a third-party follow checker, or via an API: reading a public follow relationship triggers no alert, no DM, and no trace on the other person's account.

Does the official X API have a follow-check endpoint?

Not a direct one. The X API v2 exposes a connection_status field, but it only reports relationships for the account you authenticate as, and only on higher paid tiers. To check any other pair, you must page a full follower or following list. Sorsa API's /check-follow endpoint instead returns a true or false for any two public accounts in a single request.

How do I check if two Twitter accounts follow each other?

Run two separate checks. A "mutual follow" is two one-directional follows, so you confirm that account A follows account B and that account B follows account A; if both are true, it is mutual. No tool or API returns mutual status in one call. With an API like Sorsa's /check-follow, this is two requests, one per direction.

Can I check the followers of a private (protected) account?

No. A protected account hides its follower and following lists from everyone except approved followers, so no external tool or API, including the official X API, can read its follow relationships. When you query a private account through Sorsa API, the response returns "user_protected": true so your code can handle that case cleanly instead of guessing.

Is there a free tool to check if one Twitter account follows another?

Yes. Sorsa runs a free follow checker that needs no login: enter two handles and read whether the first follows the second. It runs on Sorsa's own data infrastructure rather than scraping X, so it sidesteps the rate limits and automation flags that break older single-purpose checker sites.

How do I track new followers or unfollowers over time?

X gives no native unfollow alert beyond the basic "followed you" notification. To track changes, pull the follower list on a schedule and diff each snapshot against the last to surface new follows and unfollows. Sorsa API's /followers endpoint returns up to 200 accounts per request, which makes an hourly or daily diff practical even for large accounts.

Getting started

If you need to verify follow relationships beyond the occasional manual check, the fastest path is short:

1. Try the free tool first. Run a couple of checks in the follow checker tool, no key, no login.
2. Grab an API key from the dashboard and test /check-follow in the API playground without writing code.
3. Wire it into your workflow. Copy the Python or cURL above, or follow the quickstart for setup in other languages.

A flat 20 requests per second on every plan, a follow check from roughly $0.0018 to $0.0049 depending on plan, and a setup that takes about three minutes with no approval queue. One request, one answer, under 300 milliseconds.

Reviewed by Keksich, founder of Sorsa, marketer and X API researcher.

How this guide was put together: it draws on our own work building and operating Sorsa API and on the live endpoint behind the examples. We re-walked the manual follow checks on X directly for this update and verified the official X API's follow-relationship limits against X's developer platform follows documentation. Endpoint names, parameters, and pricing come from the Sorsa API documentation and our current rate card; questions about our setup go to the about page or contacts@sorsa.io. Last verified June 5, 2026.